pakstr 0.25.1 → 0.25.2

package/android-template/app/src/main/java/com/pakstr/app/LocalServer.kt

@@ -9,6 +9,7 @@ import fi.iki.elonen.NanoHTTPD
 import java.io.BufferedInputStream
 import java.io.ByteArrayOutputStream
 import java.io.IOException
+import java.io.PrintWriter
 import java.net.HttpURLConnection
 import java.net.InetSocketAddress
 import java.net.Socket
@@ -88,9 +89,85 @@ internal fun proxyApiUrl(
 internal data class ProxyHttpResponse(
     val code: Int,
     val contentType: String?,
-    val body: ByteArray
+    val body: ByteArray,
+    val setCookies: List<String> = emptyList()
 )
 
+internal fun proxySetCookieHeaders(
+    headers: Map<String?, List<String>>
+): List<String> = headers.entries
+    .filter { (name) -> name.equals("set-cookie", ignoreCase = true) }
+    .flatMap { (_, values) -> values }
+    .filter(::isValidProxyResponseHeaderValue)
+
+private fun isValidProxyResponseHeaderValue(value: String): Boolean =
+    '\r' !in value && '\n' !in value
+
+private class SetCookieResponse(
+    status: NanoHTTPD.Response.IStatus,
+    mimeType: String,
+    data: java.io.InputStream,
+    totalBytes: Long,
+    private val setCookies: List<String>
+) : NanoHTTPD.Response(status, mimeType, data, totalBytes) {
+    init {
+        addHeader("Set-Cookie", setCookies.first())
+    }
+
+    override fun printHeader(writer: PrintWriter, key: String, value: String) {
+        if (key.equals("set-cookie", ignoreCase = true)) {
+            setCookies.forEach { writer.append("Set-Cookie: ").append(it).append("\r\n") }
+        } else {
+            super.printHeader(writer, key, value)
+        }
+    }
+}
+
+internal fun fixedLengthProxyResponse(
+    status: NanoHTTPD.Response.IStatus,
+    mimeType: String,
+    body: ByteArray,
+    setCookies: List<String>
+): NanoHTTPD.Response {
+    val validSetCookies = setCookies.filter(::isValidProxyResponseHeaderValue)
+    if (validSetCookies.isEmpty()) {
+        return NanoHTTPD.newFixedLengthResponse(
+            status,
+            mimeType,
+            body.inputStream(),
+            body.size.toLong()
+        )
+    }
+    return SetCookieResponse(
+        status,
+        mimeType,
+        body.inputStream(),
+        body.size.toLong(),
+        validSetCookies
+    )
+}
+
+internal fun fixedLengthProxyResponse(
+    status: NanoHTTPD.Response.IStatus,
+    mimeType: String,
+    body: String,
+    setCookies: List<String>
+): NanoHTTPD.Response {
+    val validSetCookies = setCookies.filter(::isValidProxyResponseHeaderValue)
+    if (validSetCookies.isEmpty()) {
+        return NanoHTTPD.newFixedLengthResponse(status, mimeType, body)
+    }
+    val encoded = NanoHTTPD.newFixedLengthResponse(status, mimeType, body)
+    val bytes = encoded.data.use { it.readBytes() }
+    return SetCookieResponse(
+        status,
+        encoded.mimeType,
+        bytes.inputStream(),
+        bytes.size.toLong(),
+        validSetCookies
+    )
+}
+
 internal fun bodylessProxyRequestBytes(
     method: String,
     url: URL,
@@ -173,19 +250,24 @@ internal fun executeBodylessProxyRequest(
     }
 }
 
-private fun readProxyHttpResponse(input: BufferedInputStream): ProxyHttpResponse {
+internal fun readProxyHttpResponse(input: BufferedInputStream): ProxyHttpResponse {
     val statusLine = readHttpLine(input)
     val code = statusLine.split(' ', limit = 3).getOrNull(1)?.toIntOrNull()
         ?: throw IOException("Invalid HTTP status line")
     val headers = mutableMapOf<String, String>()
+    val setCookies = mutableListOf<String>()
 
     while (true) {
         val line = readHttpLine(input)
         if (line.isEmpty()) break
         val separator = line.indexOf(':')
         if (separator <= 0) throw IOException("Invalid HTTP response header")
-        headers[line.substring(0, separator).lowercase()] =
-            line.substring(separator + 1).trim()
+        val name = line.substring(0, separator).lowercase()
+        val value = line.substring(separator + 1).trim()
+        headers[name] = value
+        if (name == "set-cookie" && isValidProxyResponseHeaderValue(value)) {
+            setCookies += value
+        }
     }
 
     val body = when {
@@ -198,7 +280,7 @@ private fun readProxyHttpResponse(input: BufferedInputStream): ProxyHttpResponse
         else -> input.readBytes()
     }
 
-    return ProxyHttpResponse(code, headers["content-type"], body)
+    return ProxyHttpResponse(code, headers["content-type"], body, setCookies)
 }
 
 private fun readHttpLine(input: BufferedInputStream): String {
@@ -425,11 +507,11 @@ class LocalServer(
                         "Proxy response: ${response.code}"
                     )
                 }
-                return newFixedLengthResponse(
+                return fixedLengthProxyResponse(
                     Response.Status.lookup(response.code) ?: Response.Status.OK,
                     response.contentType ?: "application/json",
-                    response.body.inputStream(),
-                    response.body.size.toLong()
+                    response.body,
+                    response.setCookies
                 )
             }
 
@@ -496,18 +578,21 @@ class LocalServer(
                 } ?: ""
 
             val responseContentType = connection.contentType ?: "application/json"
+            val setCookies = proxySetCookieHeaders(connection.headerFields)
 
 
             connection.disconnect()
 
 
-            return newFixedLengthResponse(
+            return fixedLengthProxyResponse(
 
                 Response.Status.lookup(code) ?: Response.Status.OK,
 
                 responseContentType,
 
-                body
+                body,
+
+                setCookies
 
             )
 

package/android-template/app/src/test/java/com/pakstr/app/ProxyRequestPolicyTest.kt

@@ -6,7 +6,13 @@ import org.junit.Assert.assertNull
 import org.junit.Assert.assertThrows
 import org.junit.Assert.assertTrue
 import org.junit.Test
+import fi.iki.elonen.NanoHTTPD
+import java.io.BufferedInputStream
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.net.Socket
 import java.net.URL
+import java.nio.charset.StandardCharsets
 
 class ProxyRequestPolicyTest {
 
@@ -94,4 +100,131 @@ class ProxyRequestPolicyTest {
             )
         }
     }
+
+    @Test
+    fun rawResponsePreservesMultipleSetCookieHeaders() {
+        val body = "{\"ok\":true}"
+        val rawResponse = (
+                "HTTP/1.1 200 OK\r\n" +
+                        "Content-Type: application/json\r\n" +
+                        "Set-Cookie: session=one; Path=/; HttpOnly\r\n" +
+                        "set-cookie: refresh=two; Expires=Wed, 21 Oct 2026 07:28:00 GMT\r\n" +
+                        "Content-Length: ${body.toByteArray().size}\r\n\r\n" +
+                        body
+                ).toByteArray(StandardCharsets.ISO_8859_1)
+
+        val response = readProxyHttpResponse(
+            BufferedInputStream(ByteArrayInputStream(rawResponse))
+        )
+
+        assertEquals(200, response.code)
+        assertEquals("application/json", response.contentType)
+        assertEquals(body, response.body.toString(StandardCharsets.ISO_8859_1))
+        assertEquals(
+            listOf(
+                "session=one; Path=/; HttpOnly",
+                "refresh=two; Expires=Wed, 21 Oct 2026 07:28:00 GMT"
+            ),
+            response.setCookies
+        )
+    }
+
+    @Test
+    fun extractsSetCookieHeadersCaseInsensitively() {
+        val cookies = proxySetCookieHeaders(
+            linkedMapOf(
+                null to listOf("HTTP/1.1 200 OK"),
+                "Content-Type" to listOf("application/json"),
+                "sEt-CoOkIe" to listOf(
+                    "session=one; Path=/",
+                    "refresh=two; SameSite=Lax"
+                )
+            )
+        )
+
+        assertEquals(
+            listOf("session=one; Path=/", "refresh=two; SameSite=Lax"),
+            cookies
+        )
+    }
+
+    @Test
+    fun serializesSingleSetCookieHeader() {
+        assertEquals(
+            listOf("session=one; Path=/; HttpOnly"),
+            serializedSetCookies(listOf("session=one; Path=/; HttpOnly"))
+        )
+    }
+
+    @Test
+    fun serializesMultipleSetCookieHeadersSeparately() {
+        assertEquals(
+            listOf(
+                "session=one; Path=/; HttpOnly",
+                "refresh=two; Expires=Wed, 21 Oct 2026 07:28:00 GMT"
+            ),
+            serializedSetCookies(
+                listOf(
+                    "session=one; Path=/; HttpOnly",
+                    "refresh=two; Expires=Wed, 21 Oct 2026 07:28:00 GMT"
+                )
+            )
+        )
+    }
+
+    private fun serializedSetCookies(setCookies: List<String>): List<String> {
+        val server = object : NanoHTTPD(0) {
+            override fun serve(session: IHTTPSession): Response = fixedLengthProxyResponse(
+                Response.Status.OK,
+                "application/json",
+                "{\"ok\":true}",
+                setCookies
+            )
+        }
+
+        server.start()
+        try {
+            Socket("127.0.0.1", server.listeningPort).use { socket ->
+                socket.soTimeout = 5000
+                socket.getOutputStream().apply {
+                    write(
+                        "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n"
+                            .toByteArray(StandardCharsets.ISO_8859_1)
+                    )
+                    flush()
+                }
+
+                return readResponseHeaders(socket)
+                    .filter { it.startsWith("Set-Cookie: ") }
+                    .map { it.substringAfter(": ") }
+            }
+        } finally {
+            server.stop()
+        }
+    }
+
+    private fun readResponseHeaders(socket: Socket): List<String> {
+        val input = BufferedInputStream(socket.getInputStream())
+        assertTrue(readLine(input).startsWith("HTTP/1.1 200"))
+        return buildList {
+            while (true) {
+                val line = readLine(input)
+                if (line.isEmpty()) break
+                add(line)
+            }
+        }
+    }
+
+    private fun readLine(input: BufferedInputStream): String {
+        val bytes = ByteArrayOutputStream()
+        while (true) {
+            val value = input.read()
+            assertTrue(value != -1)
+            if (value == '\r'.code) {
+                assertEquals('\n'.code, input.read())
+                return bytes.toString(StandardCharsets.ISO_8859_1.name())
+            }
+            bytes.write(value)
+        }
+    }
 }

package/dist/android/icon.js

@@ -65,33 +65,25 @@ async function patchIcon(androidRoot, iconPath, backgroundColor = "#FFFFFF", man
         recursive: true,
     });
     const foregroundPath = path_1.default.join(adaptiveDrawablePath, "ic_launcher_foreground.webp");
-    const { isOpaque } = await (0, sharp_1.default)(absoluteIconPath).stats();
-    if (isOpaque) {
-        await (0, sharp_1.default)(absoluteIconPath)
-            .resize(432, 432, {
-            fit: "contain",
-            background: transparent,
-        })
-            .webp()
-            .toFile(foregroundPath);
-    }
-    else {
-        await (0, sharp_1.default)(absoluteIconPath)
-            .trim({ background: transparent, threshold: 0 })
-            .resize(264, 264, {
-            fit: "contain",
-            background: transparent,
-        })
-            .extend({
-            top: 84,
-            bottom: 84,
-            left: 84,
-            right: 84,
-            background: transparent,
-        })
-            .webp()
-            .toFile(foregroundPath);
-    }
+    const adaptiveCanvasSize = 432;
+    // Fit square artwork inside Android's 264px guaranteed-safe circle.
+    const safeArtworkSize = 186;
+    const adaptivePadding = (adaptiveCanvasSize - safeArtworkSize) / 2;
+    await (0, sharp_1.default)(absoluteIconPath)
+        .trim({ background: transparent, threshold: 0 })
+        .resize(safeArtworkSize, safeArtworkSize, {
+        fit: "contain",
+        background: transparent,
+    })
+        .extend({
+        top: adaptivePadding,
+        bottom: adaptivePadding,
+        left: adaptivePadding,
+        right: adaptivePadding,
+        background: transparent,
+    })
+        .webp()
+        .toFile(foregroundPath);
     console.log("🖼️ Generated adaptive foreground");
     //
     // 3. REMOVE OLD UNQUALIFIED FOREGROUNDS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.25.1",
+  "version": "0.25.2",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",