@typed-assistant/builder 0.0.22 → 0.0.24

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.22",
+  "version": "0.0.24",
   "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/typescript-config": "0.0.4",
-    "@typed-assistant/utils": "0.0.7",
-    "@typed-assistant/logger": "0.0.8"
+    "@typed-assistant/eslint-config": "0.0.5",
+    "@typed-assistant/logger": "0.0.9",
+    "@typed-assistant/typescript-config": "0.0.5",
+    "@typed-assistant/utils": "0.0.8"
   },
   "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,15 +1,21 @@
-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"
-import { $ } from "bun"
 
 type Processes = Awaited<ReturnType<typeof buildAndStartAppProcess>>
 
@@ -30,12 +36,6 @@ async function startApp(appSourceFile: string) {
   })
 }
 
-async function kill(process: Subprocess) {
-  log(`💀 Killing process: ${process.pid}`)
-  process.kill()
-  await process.exited
-}
-
 let settingUp = { current: false }
 async function killAndRestartApp(
   entryFile: string,
@@ -45,7 +45,7 @@ async function killAndRestartApp(
   if (settingUp.current) return subprocesses
   log("♻️ Restarting app...")
   settingUp.current = true
-  if (subprocesses.app) await kill(subprocesses.app)
+  if (subprocesses.app) await killSubprocess(subprocesses.app)
   const newSubprocesses = await buildAndStartAppProcess(entryFile, options)
   settingUp.current = false
   return newSubprocesses
@@ -62,7 +62,7 @@ const checkProcesses = async (
 
   if (matches.length > 1) {
     multipleProcessesErrorCount++
-    if (multipleProcessesErrorCount > 3) {
+    if (multipleProcessesErrorCount > 5) {
       const message = `🚨 Multiple processes detected. Restarting TypedAssistant addon...`
       log(message)
       onProcessError?.(message)
@@ -74,7 +74,7 @@ const checkProcesses = async (
 
   if (matches.length === 0) {
     noProcessesErrorCount++
-    if (noProcessesErrorCount > 3) {
+    if (noProcessesErrorCount > 5) {
       const message = `🚨 No processes detected. Restarting TypedAssistant addon...`
       log(message)
       onProcessError?.(message)
@@ -87,7 +87,7 @@ const checkProcesses = async (
   setTimeout(() => checkProcesses(entryFile, { onProcessError }), 5000)
 }
 
-export async function setupWatcher({
+export async function setup({
   entryFile,
   mdiPaths,
   onProcessError,
@@ -95,65 +95,50 @@ export async function setupWatcher({
   entryFile: string
 } & Parameters<typeof generateTypes>[0] &
   Parameters<typeof checkProcesses>[1]) {
-  const { data: addonInfo, error: addonInfoError } = await getAddonInfo()
-  if (addonInfoError) {
-    log(`🚨 Failed to get addon info: ${addonInfoError}`)
-  }
-  await setupGitSync()
+  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,
   })
-
-  const directory = join(process.cwd(), "./src")
-  log("👀 Watching directory:", directory)
-  const watcher = watch(
-    directory,
-    { 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 {
-        subprocesses = await killAndRestartApp(
-          entryFile,
-          { mdiPaths },
-          subprocesses,
-        )
-      }
-    },
-  )
-
   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(
@@ -169,20 +154,66 @@ const restartAddon = async () => {
     return
   }
   log("♻️ Restarting addon...")
-  await getHassAPI(`http://supervisor/addons/self/restart`, { method: "POST" })
+  await getSupervisorAPI(`/addons/self/restart`, { method: "POST" })
 }
 
 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"])
+  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/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"
-    }`,
-  )
-}