@typed-assistant/builder 0.0.21 → 0.0.23

package/.eslintrc.js

@@ -1,7 +1,7 @@
 /** @type {import("eslint").Linter.Config} */
 module.exports = {
   root: true,
-  extends: ["@typed-assistant/eslint-config/react-internal.js"],
-  plugins: ['html'],  
+  extends: ["@typed-assistant/eslint-config"],
+  plugins: ["html"],
   parserOptions: {},
 }

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@typed-assistant/builder",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "exports": {
     "./appProcess": "./src/appProcess.tsx",
     "./bunInstall": "./src/bunInstall.tsx",
-    "./getSpawnText": "./src/getSpawnText.tsx",
     "./pullChanges": "./src/pullChanges.tsx"
   },
   "dependencies": {
@@ -14,7 +13,8 @@
     "@mdi/svg": "^7.3.67",
     "ignore": "^5.3.0",
     "react": "^18",
-    "react-dom": "^18"
+    "react-dom": "^18",
+    "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/node": "^20.10.6",
@@ -24,10 +24,10 @@
     "home-assistant-js-websocket": "^8.2.0",
     "ts-toolbelt": "^9.6.0",
     "typescript": "^5.3.3",
-    "@typed-assistant/eslint-config": "0.0.4",
-    "@typed-assistant/logger": "0.0.7",
-    "@typed-assistant/utils": "0.0.7",
-    "@typed-assistant/typescript-config": "0.0.4"
+    "@typed-assistant/eslint-config": "0.0.5",
+    "@typed-assistant/typescript-config": "0.0.5",
+    "@typed-assistant/utils": "0.0.8",
+    "@typed-assistant/logger": "0.0.9"
   },
   "peerDependencies": {
     "home-assistant-js-websocket": "^8.2.0"
@@ -37,6 +37,6 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "lint": "eslint . --max-warnings 0"
+    "lint": "tsc --noEmit && eslint ."
   }
 }

package/src/appProcess.tsx

@@ -1,26 +1,33 @@
-import { generateTypes } from "@typed-assistant/types/generateTypes"
 import { log } from "@typed-assistant/logger"
+import { generateTypes } from "@typed-assistant/types/generateTypes"
+import { getHassAPI, getSupervisorAPI } from "@typed-assistant/utils/getHassAPI"
+import { withErrorHandling } from "@typed-assistant/utils/withErrorHandling"
 import type { Subprocess } from "bun"
+import { $ } from "bun"
 import { readFileSync, watch } from "fs"
-import { join, relative } from "path"
 import ignore from "ignore"
-import { ONE_SECOND } from "@typed-assistant/utils/durations"
-import { getHassAPI, getSupervisorAPI } from "@typed-assistant/utils/getHassAPI"
-import { pullChanges } from "./pullChanges"
-import { withErrorHandling } from "@typed-assistant/utils/withErrorHandling"
+import { join, relative } from "path"
+import {
+  addKillListener,
+  callKillListeners,
+  callSoftKillListeners,
+  killSubprocess,
+} from "./killProcess"
+import { setupGitPoller } from "./setupGitPoller"
+import { setupWebhook } from "./setupWebhook"
 import { startWebappServer } from "./setupWebserver"
 
 type Processes = Awaited<ReturnType<typeof buildAndStartAppProcess>>
 
 async function buildAndStartAppProcess(
-  appSourceFile?: string,
-  options?: Parameters<typeof generateTypes>[0],
+  appSourceFile: string,
+  options: Parameters<typeof generateTypes>[0],
 ) {
   await generateTypes({ mdiPaths: options?.mdiPaths })
   return { app: await startApp(appSourceFile) }
 }
 
-async function startApp(appSourceFile: string = "src/entry.tsx") {
+async function startApp(appSourceFile: string) {
   log("🚀 Starting app...")
   const path = join(process.cwd(), appSourceFile)
   return Bun.spawn(["bun", path], {
@@ -29,79 +36,109 @@ async function startApp(appSourceFile: string = "src/entry.tsx") {
   })
 }
 
-async function kill(process: Subprocess) {
-  log(`💀 Killing process: ${process.pid}`)
-  process.kill()
-  await process.exited
-}
-
 let settingUp = { current: false }
-async function killAndRestartApp(subprocesses: Processes) {
+async function killAndRestartApp(
+  entryFile: string,
+  options: Parameters<typeof buildAndStartAppProcess>[1],
+  subprocesses: Processes,
+) {
   if (settingUp.current) return subprocesses
   log("♻️ Restarting app...")
   settingUp.current = true
-  if (subprocesses.app) await kill(subprocesses.app)
-  const newSubprocesses = await buildAndStartAppProcess()
+  if (subprocesses.app) await killSubprocess(subprocesses.app)
+  const newSubprocesses = await buildAndStartAppProcess(entryFile, options)
   settingUp.current = false
   return newSubprocesses
 }
 
-export async function setupWatcher(
-  ...args: Parameters<typeof buildAndStartAppProcess>
-) {
-  const { data: addonInfo, error: addonInfoError } = await getAddonInfo()
-  if (addonInfoError) {
-    log(`🚨 Failed to get addon info: ${addonInfoError}`)
+let multipleProcessesErrorCount = 0
+let noProcessesErrorCount = 0
+const checkProcesses = async (
+  entryFile: string,
+  { onProcessError }: { onProcessError?: (message: string) => void },
+) => {
+  const ps = await $`ps -f`.text()
+  const matches = ps.match(new RegExp(`bun .+${entryFile}`, "gmi")) ?? []
+
+  if (matches.length > 1) {
+    multipleProcessesErrorCount++
+    if (multipleProcessesErrorCount > 5) {
+      const message = `🚨 Multiple processes detected. Restarting TypedAssistant addon...`
+      log(message)
+      onProcessError?.(message)
+      restartAddon()
+    }
+  } else {
+    multipleProcessesErrorCount = 0
   }
-  await setupGitSync()
 
-  let subprocesses = await buildAndStartAppProcess(...args)
+  if (matches.length === 0) {
+    noProcessesErrorCount++
+    if (noProcessesErrorCount > 5) {
+      const message = `🚨 No processes detected. Restarting TypedAssistant addon...`
+      log(message)
+      onProcessError?.(message)
+      restartAddon()
+    }
+  } else {
+    noProcessesErrorCount = 0
+  }
 
-  const directory = join(process.cwd(), "./src")
-  log("👀 Watching directory:", directory)
-  const watcher = watch(
-    directory,
-    { recursive: true },
-    async function onFileChange(event, filename) {
-      console.log("😅😅😅 ~ filename:", filename)
-      if (!filename) return
-      if (shouldIgnoreFileOrFolder(filename)) return
-      log(`⚠️ Change to ${filename} detected.`)
-      if (filename.endsWith("process.tsx")) {
-        await restartAddon()
-      } else {
-        subprocesses = await killAndRestartApp(subprocesses)
-      }
-    },
-  )
+  setTimeout(() => checkProcesses(entryFile, { onProcessError }), 5000)
+}
+
+export async function setup({
+  entryFile,
+  mdiPaths,
+  onProcessError,
+}: {
+  entryFile: string
+} & Parameters<typeof generateTypes>[0] &
+  Parameters<typeof checkProcesses>[1]) {
+  const addonInfo = await getAddonInfo()
+  const basePath = addonInfo?.data.ingress_entry ?? ""
+  const directoryToWatch = join(process.cwd(), "./src")
+
+  checkProcesses(entryFile, { onProcessError })
+  await setupGitSync()
 
+  let subprocesses = await buildAndStartAppProcess(entryFile, {
+    mdiPaths: mdiPaths,
+  })
   startWebappServer({
-    basePath: addonInfo?.data.ingress_entry ?? "",
+    basePath,
     getSubprocesses: () => subprocesses,
   })
-
-  process.on("SIGINT", () => {
-    console.log("👋 Closing watcher...")
-    watcher.close()
+  setupWatcher({
+    directoryToWatch,
+    entryFile,
+    mdiPaths,
+    onSubprocessChange: (newSubprocesses) => {
+      subprocesses = newSubprocesses
+    },
+    getSubprocesses: () => subprocesses,
   })
 
   return subprocesses
 }
 
-const setupGitSync = async ({
-  gitPullPollDuration,
-}: {
-  /** Duration in seconds */
-  gitPullPollDuration?: number
-} = {}) => {
-  const duration = gitPullPollDuration ?? 30
-  const { error } = await pullChanges()
-  if (error) return
-  log(`   ⏳ Pulling changes again in ${duration} seconds...`)
-
-  setTimeout(() => {
-    setupGitSync({ gitPullPollDuration })
-  }, duration * ONE_SECOND)
+const setupGitSync = async () => {
+  if (
+    !process.env.GITHUB_TOKEN ||
+    !process.env.GITHUB_USERNAME ||
+    !process.env.GITHUB_REPO
+  ) {
+    log(
+      "⚠️ Cannot sync with Github without Github token, username, and repo details. Add these in the add-on configuration.",
+    )
+    return { error: {} }
+  }
+  if (process.env.HASS_EXTERNAL_URL) {
+    await setupWebhook()
+    return
+  }
+  log("⚠️ No HASS_EXTERNAL_URL found. Setting up git poller...")
+  await setupGitPoller()
 }
 
 const ig = ignore().add(
@@ -123,14 +160,60 @@ const restartAddon = async () => {
 const getAddonInfo = async () => {
   log("🔍 Getting addon info...")
 
-  return withErrorHandling(getSupervisorAPI)<{
+  const { data, error } = await withErrorHandling(getSupervisorAPI)<{
     data: { ingress_entry: string }
   }>("/addons/self/info")
+
+  if (error) log(`🚨 Failed to get addon info: ${error}`)
+
+  return data
 }
 
-process.on("SIGINT", () => {
-  setTimeout(() => {
-    console.log("👋 ...")
-    process.exit(0)
-  }, 0)
+function setupWatcher({
+  directoryToWatch,
+  entryFile,
+  mdiPaths,
+  onSubprocessChange,
+  getSubprocesses,
+}: {
+  directoryToWatch: string
+  onSubprocessChange: (newSubprosses: {
+    app: Subprocess<"ignore", "pipe", "pipe">
+  }) => void
+  entryFile: string
+  mdiPaths: string[] | undefined
+  getSubprocesses: () => {
+    app: Subprocess<"ignore", "pipe", "pipe">
+  }
+}) {
+  log("👀 Watching directory:", directoryToWatch)
+  const watcher = watch(
+    directoryToWatch,
+    { recursive: true },
+    async function onFileChange(event, filename) {
+      if (!filename) return
+      if (shouldIgnoreFileOrFolder(filename)) return
+      log(`⚠️ Change to ${filename} detected.`)
+      if (filename.endsWith("process.tsx")) {
+        await restartAddon()
+      } else {
+        onSubprocessChange(
+          await killAndRestartApp(entryFile, { mdiPaths }, getSubprocesses()),
+        )
+      }
+    },
+  )
+
+  addKillListener(() => {
+    if (watcher) watcher.close()
+  })
+
+  return watcher
+}
+
+process.on("SIGINT", async () => {
+  log("👋 Exiting...")
+  await callSoftKillListeners()
+  await callKillListeners()
+  process.exit(0)
 })

package/src/bunInstall.tsx

@@ -1,21 +1,11 @@
 import { log } from "@typed-assistant/logger"
+import { $ } from "bun"
 
 export async function bunInstall() {
   log("🏗️ Running bun install...")
-  const proc = Bun.spawn([
-    "bun",
-    "install",
-    "--frozen-lockfile",
-    "--cache-dir=.bun-cache",
-  ])
-  await proc.exited
-  const bunInstallText = await Bun.readableStreamToText(proc.stdout)
-  if (proc.exitCode === 0) return { error: null }
-  return {
-    error: {
-      signalCode: proc.signalCode,
-      exitCode: proc.exitCode,
-      text: bunInstallText,
-    },
-  }
+  return $`bun install --frozen-lockfile --cache-dir=.bun-cache`
+    .text()
+    .catch((error) => {
+      log(`🚨 Failed to run bun install: ${error}`)
+    })
 }

package/src/killProcess.tsx

@@ -0,0 +1,32 @@
+import { log } from "@typed-assistant/logger"
+import type { Subprocess } from "bun"
+import { $ } from "bun"
+
+const killListeners: (() => void | Promise<void>)[] = []
+const softKillListeners: (() => void | Promise<void>)[] = []
+
+export const addKillListener = (listener: () => void | Promise<void>) => {
+  killListeners.push(listener)
+}
+export const addSoftKillListener = (listener: () => void | Promise<void>) => {
+  softKillListeners.push(listener)
+}
+
+export async function callKillListeners() {
+  log("👋 Calling kill listeners!")
+  await Promise.all(killListeners.map((listener) => listener()))
+  log("👋 Called all kill listeners!")
+}
+
+export async function callSoftKillListeners() {
+  log("👋 Calling soft kill listeners!")
+  await Promise.all(softKillListeners.map((listener) => listener()))
+  log("👋 Called all soft kill listeners!")
+}
+
+export async function killSubprocess(subprocess: Subprocess) {
+  log(`💀 Killing process: ${subprocess.pid}`)
+  await callSoftKillListeners()
+  subprocess.kill()
+  await subprocess.exited
+}

package/src/pullChanges.tsx

@@ -1,20 +1,10 @@
 import { log } from "@typed-assistant/logger"
-import { getSpawnText } from "./getSpawnText"
+import { $ } from "bun"
 import { bunInstall } from "./bunInstall"
 
 export const pullChanges = async () => {
-  if (
-    !process.env.GITHUB_TOKEN ||
-    !process.env.GITHUB_USERNAME ||
-    !process.env.GITHUB_REPO
-  ) {
-    log(
-      "⚠️  Cannot pull changes without GITHUB_TOKEN, GITHUB_USERNAME, and GITHUB_REPO environment variables.",
-    )
-    return { error: {} }
-  }
-  log("⬇️  Pulling changes...")
-  const gitPullText = await getSpawnText(["git", "pull"])
+  log("⬇️ Pulling changes...")
+  const gitPullText = await $`git pull`.text()
   const packageJSONUpdated = /package.json/.test(gitPullText)
   const nothingNew = /Already up to date./.test(gitPullText)
   if (nothingNew) {
@@ -25,8 +15,7 @@ export const pullChanges = async () => {
   }
   if (packageJSONUpdated) {
     log("   📦 package.json updated.")
-    const { error } = await bunInstall()
-    if (error) throw new Error(error.text)
+    await bunInstall()
   }
   return {}
 }

package/src/setupGitPoller.tsx

@@ -0,0 +1,19 @@
+import { log } from "@typed-assistant/logger"
+import { ONE_SECOND } from "@typed-assistant/utils/durations"
+import { pullChanges } from "./pullChanges"
+
+export const setupGitPoller = async ({
+  gitPullPollDuration,
+}: {
+  /** Duration in seconds */
+  gitPullPollDuration?: number
+} = {}) => {
+  const duration = gitPullPollDuration ?? 30
+  const { error } = await pullChanges()
+  if (error) return
+  log(`   ⏳ Pulling changes again in ${duration} seconds...`)
+
+  setTimeout(() => {
+    setupGitPoller({ gitPullPollDuration })
+  }, duration * ONE_SECOND)
+}

package/src/setupWebhook.tsx

@@ -0,0 +1,159 @@
+import { log } from "@typed-assistant/logger"
+import { withErrorHandling } from "@typed-assistant/utils/withErrorHandling"
+import { z } from "zod"
+
+const webhookUrl = `${process.env.HASS_EXTERNAL_URL}/webhook`
+
+const commonOptions = {
+  headers: {
+    Accept: "application/vnd.github+json",
+    Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
+    "X-GitHub-Api-Version": "2022-11-28",
+  },
+}
+
+const listRepoWebhooks = async () =>
+  withErrorHandling(() =>
+    fetch(
+      `https://api.github.com/repos/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_REPO}/hooks`,
+      { ...commonOptions },
+    )
+      .then(handleFetchError)
+      .then((d) => d?.json())
+      .then(z.array(Webhook).parse),
+  )()
+
+const deleteRepoWebhook = async (id: number) =>
+  withErrorHandling(() =>
+    fetch(
+      `https://api.github.com/repos/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_REPO}/hooks/${id}`,
+      { ...commonOptions, method: "DELETE" },
+    ),
+  )()
+
+const deleteAllRepoWebhooks = async () => {
+  const { data: webhooks, error } = await listRepoWebhooks()
+
+  if (error) {
+    log("🚨 Failed fetching webhooks", error.message)
+    return
+  }
+
+  await Promise.all(
+    webhooks.map(async (webhook) => {
+      await deleteRepoWebhook(webhook.id)
+      log("🚮 Webhook deleted: ", webhook.config.url)
+    }),
+  )
+}
+
+const createRepoWebhook = async () =>
+  withErrorHandling(() =>
+    fetch(
+      `https://api.github.com/repos/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_REPO}/hooks`,
+      {
+        ...commonOptions,
+        method: "POST",
+        body: JSON.stringify({
+          name: "web",
+          active: true,
+          config: {
+            url: webhookUrl,
+            content_type: "json",
+            insecure_ssl: "0",
+          },
+          events: ["push"],
+        }),
+      },
+    )
+      .then(handleFetchError)
+      .then((d) => d.json())
+      .then(Webhook.parse),
+  )()
+
+const Webhook = z.object({
+  type: z.literal("Repository"),
+  id: z.number(),
+  name: z.literal("web"),
+  active: z.boolean(),
+  events: z.array(z.string()),
+  config: z.object({
+    content_type: z.string(),
+    insecure_ssl: z.enum(["0", "1"]),
+    url: z.string(),
+  }),
+  updated_at: z.string(),
+  created_at: z.string(),
+  url: z.string(),
+  test_url: z.string(),
+  ping_url: z.string(),
+  deliveries_url: z.string(),
+  last_response: z.object({
+    code: z.number().nullable(),
+    status: z.string().nullable(),
+    message: z.string().nullable(),
+  }),
+})
+
+type Webhook = z.infer<typeof Webhook>
+
+const handleFetchError = async (d: Response): Promise<Response> => {
+  if (!d.ok)
+    throw new Error(
+      d.status +
+        " " +
+        d.statusText +
+        (d.headers.get("Content-Type")?.includes("application/json")
+          ? `:\n${JSON.stringify(await d.json(), null, 2)}`
+          : ""),
+    )
+  return d
+}
+
+const retryTimeout = 2000
+let retries = 0
+export const setupWebhook = async (): Promise<void> => {
+  const { data: webhooks, error } = await listRepoWebhooks()
+
+  if (error) {
+    if (retries < 5) {
+      retries++
+      log(
+        `🔁 Failed fetching webhooks. Retrying setup in ${retryTimeout / 1000}s...`,
+      )
+      setTimeout(setupWebhook, retryTimeout)
+      return
+    }
+    log("🚨 Failed fetching webhooks. Giving up.", error.message)
+    return
+  }
+
+  const webhookAlreadyExists = webhooks.some(
+    async (webhook) => webhook.config.url === webhookUrl,
+  )
+
+  if (webhookAlreadyExists) {
+    log("🪝 Webhook already set up")
+    return
+  }
+
+  const { data: webhook, error: createError } = await createRepoWebhook()
+
+  if (createError) {
+    if (retries < 5) {
+      retries++
+      log(
+        `🔁 Failed creating webhook. Retrying setup in ${retryTimeout / 1000}s...`,
+      )
+      setTimeout(setupWebhook, retryTimeout)
+      return
+    }
+    log("🚨 Failed creating webhook. Giving up.", createError.message)
+    return
+  }
+
+  log("🪝 Webhook created: ", webhook.config.url)
+}
+
+// await setupWebhook()
+// await deleteAllRepoWebhooks()

package/src/setupWebserver.tsx

@@ -6,6 +6,7 @@ import { Elysia, t } from "elysia"
 import { watch } from "fs"
 import { basename, join } from "path"
 import type { List, String } from "ts-toolbelt"
+import { addKillListener, addSoftKillListener } from "./killProcess"
 
 const indexHtmlFilePath = `${import.meta.dir}/webserver/index.html` as const
 const cssFile = `${import.meta.dir}/webserver/input.css` as const
@@ -159,10 +160,9 @@ export const startWebappServer = async ({
     }
   })
 
-  process.on("SIGINT", () => {
-    console.log("👋 Closing log watcher...")
+  addKillListener(async () => {
     watcher.close()
-    server.stop()
+    await server.stop()
   })
 
   // eslint-disable-next-line no-constant-condition
@@ -170,7 +170,8 @@ export const startWebappServer = async ({
     const stdoutReader = getReader(getSubprocesses().app.stdout)
     const { value } = await stdoutReader.read()
 
-    const convertedMessage = convert.toHtml(decoder.decode(value))
+    const newLocal = decoder.decode(value)
+    const convertedMessage = convert.toHtml(newLocal)
     if (convertedMessage !== "") {
       lastMessage = convertedMessage
     }

package/src/webserver/App.tsx

@@ -20,7 +20,12 @@ const App = () => {
 
 const Logs = () => {
   const [limit, setLimit] = useState(50)
-  const [logs, setLogs] = useState<string[]>([])
+  const [dateTimeVisibility, setDateTimeVisibility] = useState<
+    "hidden" | "timeOnly" | "visible"
+  >("timeOnly")
+  const [logs, setLogs] = useState<
+    { date: string; time: string; message: string }[]
+  >([])
 
   const ws = useWS({
     subscribe: useCallback(
@@ -28,7 +33,13 @@ const Logs = () => {
       [limit],
     ),
     onMessage: useCallback((event) => {
-      setLogs(JSON.parse(event.data).logs)
+      setLogs(
+        (JSON.parse(event.data).logs as string[]).map((log: string) => {
+          const [date, time, message] =
+            log.match(/\[(.+), (.+)\] +(.+)/)?.slice(1) ?? []
+          return { date: date ?? "", time: time ?? "", message: message ?? log }
+        }),
+      )
     }, []),
   })
 
@@ -39,15 +50,34 @@ const Logs = () => {
           <h2 className="mb-2 text-2xl flex items-baseline gap-3">
             Logs <WSIndicator ws={ws.ws} />
           </h2>
-          <div className="flex gap-2">
-            <label htmlFor="limit">Limit</label>
-            <input
-              className="border border-gray-300 rounded-md text-slate-800 px-2"
-              id="limit"
-              onChange={(e) => setLimit(Number(e.target.value))}
-              size={8}
-              value={limit}
-            />
+          <div className="flex flex-wrap gap-2">
+            <div className="flex gap-2">
+              <label htmlFor="dateTimeVisibility">Date/Time</label>
+              <select
+                className="border border-gray-300 rounded-md text-slate-800 px-2"
+                id="dateTimeVisibility"
+                onChange={(e) =>
+                  setDateTimeVisibility(
+                    e.target.value as typeof dateTimeVisibility,
+                  )
+                }
+                value={dateTimeVisibility}
+              >
+                <option value="hidden">Hidden</option>
+                <option value="timeOnly">Time only</option>
+                <option value="visible">Visible</option>
+              </select>
+            </div>
+            <div className="flex gap-2">
+              <label htmlFor="limit">Limit</label>
+              <input
+                className="border border-gray-300 rounded-md text-slate-800 px-2"
+                id="limit"
+                onChange={(e) => setLimit(Number(e.target.value))}
+                size={8}
+                value={limit}
+              />
+            </div>
           </div>
         </>
       )}
@@ -55,7 +85,16 @@ const Logs = () => {
       <pre>
         <ul>
           {logs.map((log) => (
-            <li key={log}>{log}</li>
+            <li key={log.date + log.time + log.message} className="">
+              <span className="text-slate-400 mr-2">
+                {dateTimeVisibility === "hidden"
+                  ? null
+                  : dateTimeVisibility === "timeOnly"
+                    ? log.time
+                    : `${log.date} ${log.time}`}
+              </span>
+              {log.message}
+            </li>
           ))}
         </ul>
       </pre>

package/src/webserver/AppSection.tsx

@@ -7,7 +7,7 @@ export const AppSection = ({
 }) => {
   return (
     <div className="p-4 text-xs h-full max-h-dvh w-dvw md:w-auto overflow-x-auto flex flex-col">
-      <div className="flex gap-4 mb-4 items-center justify-between">
+      <div className="flex flex-wrap gap-4 mb-4 items-center justify-between">
         {renderHeader()}
       </div>
       <div className="overflow-x-auto">{children}</div>

package/src/webserver/useWS.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react"
-import { app } from "./api"
+import type { app } from "./api"
 
 export function useWS({
   onMessage,

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "@typed-assistant/typescript-config/react-app.json",
+  "extends": "@typed-assistant/typescript-config/react.json",
   "compilerOptions": {
     "paths": {
       "@elysiajs/eden": ["./node_modules/@elysiajs/eden/"],

package/src/getSpawnText.tsx

@@ -1,14 +0,0 @@
-export async function getSpawnText(...args: Parameters<typeof Bun.spawn>) {
-  const { exitCode, exited, stderr, stdout } = Bun.spawn(...args)
-  await exited
-  if (exitCode === 0 || exitCode === null)
-    return await Bun.readableStreamToText(stdout)
-  if (!exitCode) return ""
-  throw new Error(
-    `Failed to run command: "${args.join(
-      " ",
-    )}". Exit code: ${exitCode}. Stderr: ${
-      stderr ? await Bun.readableStreamToText(stderr) : "None"
-    }`,
-  )
-}