@typed-assistant/builder 0.0.82 → 0.0.84

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @typed-assistant/builder
 
+## 0.0.84
+
+### Patch Changes
+
+- Improve logging for random crashes.
+
+## 0.0.83
+
+### Patch Changes
+
+- Undo last fix.
+
 ## 0.0.82
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed-assistant/builder",
-  "version": "0.0.82",
+  "version": "0.0.84",
   "exports": {
     "./appProcess": "./src/appProcess.tsx",
     "./bunInstall": "./src/bunInstall.tsx",
@@ -28,10 +28,10 @@
     "eslint-plugin-html": "^7.1.0",
     "ts-toolbelt": "^9.6.0",
     "typescript": "^5.4.0",
+    "@typed-assistant/eslint-config": "0.0.10",
     "@typed-assistant/logger": "0.0.22",
-    "@typed-assistant/typescript-config": "0.0.10",
-    "@typed-assistant/utils": "0.0.19",
-    "@typed-assistant/eslint-config": "0.0.10"
+    "@typed-assistant/typescript-config": "0.0.11",
+    "@typed-assistant/utils": "0.0.19"
   },
   "publishConfig": {
     "access": "public",

package/src/setupWebserver.tsx

@@ -45,13 +45,7 @@ const getReader = (
 ) => {
   const cachedReader = readers[type].get(stream)
   if (!cachedReader) {
-    readers[type].forEach((reader, cachedStream) => {
-      // Properly release the lock before deleting
-      try {
-        reader.releaseLock()
-      } catch (e) {
-        // Ignore if already released
-      }
+    readers[type].forEach((_reader, cachedStream) => {
       readers[type].delete(cachedStream)
     })
   }
@@ -71,8 +65,6 @@ let stats = {
   memory_percent: null as number | null,
   max_memory_usage: 0,
 }
-let statsInterval: ReturnType<typeof setInterval> | null = null
-
 const getStats = async () => {
   const { data, error } = await withErrorHandling(
     getSupervisorAPI<{
@@ -101,6 +93,8 @@ const getStats = async () => {
           : stats.max_memory_usage,
     }
   }
+
+  setTimeout(getStats, 10 * ONE_SECOND)
 }
 
 export const startWebappServer = async ({
@@ -239,7 +233,14 @@ export const startWebappServer = async ({
       }),
 
       async open(ws) {
-        // Set the log subscriber first to avoid race conditions
+        ws.send(
+          await getLogsFromFile({
+            filter: ws.data.query.filter,
+            level: ws.data.query.level,
+            limit: ws.data.query.limit,
+            offset: ws.data.query.offset,
+          }),
+        )
         logSubscribers.set(ws.id, async () => {
           ws.send(
             await getLogsFromFile({
@@ -250,15 +251,6 @@ export const startWebappServer = async ({
             }),
           )
         })
-        // Then send the initial logs
-        ws.send(
-          await getLogsFromFile({
-            filter: ws.data.query.filter,
-            level: ws.data.query.level,
-            limit: ws.data.query.limit,
-            offset: ws.data.query.offset,
-          }),
-        )
       },
       close(ws) {
         logSubscribers.delete(ws.id)
@@ -345,49 +337,44 @@ export const startWebappServer = async ({
 
   watchLogFileSize()
 
-  // Start stats polling interval
-  statsInterval = setInterval(getStats, 10 * 1000)
+  getStats()
 
   addKillListener(async () => {
     watcher.close()
     await server.stop()
-    // Clean up all websocket subscribers
-    subscribers.clear()
-    logSubscribers.clear()
-    // Release and clear all readers
-    for (const reader of readers.stdout.values()) {
-      try {
-        reader.releaseLock()
-      } catch (e) {
-        /* ignore */
-      }
-    }
-    for (const reader of readers.stderr.values()) {
-      try {
-        reader.releaseLock()
-      } catch (e) {
-        /* ignore */
-      }
-    }
-    readers.stdout.clear()
-    readers.stderr.clear()
-    // Clear stats polling interval
-    if (statsInterval) clearInterval(statsInterval)
   })
 
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    getSubprocesses().app.exitCode
-    const stdoutReader = getReader("stdout", getSubprocesses().app.stdout)
-    const stderrReader = getReader("stderr", getSubprocesses().app.stderr)
-    const { value } = await stdoutReader.read()
-    const { value: stderrValue } = value
-      ? { value: undefined }
-      : await stderrReader.read()
-
-    const decodedString = stderrValue
-      ? decoder.decode(stderrValue)
-      : decoder.decode(value)
+    const app = getSubprocesses().app
+    const stdoutReader = getReader("stdout", app.stdout)
+    const stderrReader = getReader("stderr", app.stderr)
+    const stdoutResult = await stdoutReader.read()
+    const stderrResult =
+      stdoutResult.value === undefined
+        ? await stderrReader.read()
+        : ({
+            value: undefined,
+            done: true,
+          } satisfies ReadableStreamDefaultReadDoneResult)
+
+    const streamEnded =
+      stdoutResult.done &&
+      (stderrResult.done || stderrResult.value === undefined)
+    if (streamEnded) {
+      logger.warn(
+        {
+          emoji: "😴",
+          additionalDetails: JSON.stringify({ exitCode: app.exitCode }),
+        },
+        "Subprocess output streams ended; waiting for restart or new output",
+      )
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+      continue
+    }
+
+    const chunk = stdoutResult.value ?? stderrResult.value
+    const decodedString = chunk ? decoder.decode(chunk) : ""
     const convertedMessage = convert.toHtml(decodedString)
     if (convertedMessage !== "") {
       lastMessage = convertedMessage
@@ -404,14 +391,12 @@ export const startWebappServer = async ({
           emoji: "💀",
           additionalDetails: JSON.stringify({
             exitCode: getSubprocesses().app.exitCode,
-            stderrValue,
-            stderrValueDecoded: decodedString,
           }),
         },
-        "Process is returning an empty string. Restarting app...",
+        "Process is returning an empty string",
       )
-      onRestartAppRequest()
-      break
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+      continue
     }
     subscribers.forEach((send) => send(convertedMessage))
   }