@jonsoc/app 1.1.34

package/src/context/terminal.tsx

@@ -0,0 +1,267 @@
+import { createStore, produce } from "solid-js/store"
+import { createSimpleContext } from "@jonsoc/ui/context"
+import { batch, createEffect, createMemo, createRoot, onCleanup } from "solid-js"
+import { useParams } from "@solidjs/router"
+import { useSDK } from "./sdk"
+import { Persist, persisted } from "@/utils/persist"
+
+export type LocalPTY = {
+  id: string
+  title: string
+  titleNumber: number
+  rows?: number
+  cols?: number
+  buffer?: string
+  scrollY?: number
+  error?: boolean
+}
+
+const WORKSPACE_KEY = "__workspace__"
+const MAX_TERMINAL_SESSIONS = 20
+
+type TerminalSession = ReturnType<typeof createTerminalSession>
+
+type TerminalCacheEntry = {
+  value: TerminalSession
+  dispose: VoidFunction
+}
+
+function createTerminalSession(sdk: ReturnType<typeof useSDK>, dir: string, session?: string) {
+  const legacy = session ? [`${dir}/terminal/${session}.v1`, `${dir}/terminal.v1`] : [`${dir}/terminal.v1`]
+
+  const numberFromTitle = (title: string) => {
+    const match = title.match(/^Terminal (\d+)$/)
+    if (!match) return
+    const value = Number(match[1])
+    if (!Number.isFinite(value) || value <= 0) return
+    return value
+  }
+
+  const [store, setStore, _, ready] = persisted(
+    Persist.workspace(dir, "terminal", legacy),
+    createStore<{
+      active?: string
+      all: LocalPTY[]
+    }>({
+      all: [],
+    }),
+  )
+
+  const unsub = sdk.event.on("pty.exited", (event) => {
+    const id = event.properties.id
+    if (!store.all.some((x) => x.id === id)) return
+    batch(() => {
+      setStore(
+        "all",
+        store.all.filter((x) => x.id !== id),
+      )
+      if (store.active === id) {
+        const remaining = store.all.filter((x) => x.id !== id)
+        setStore("active", remaining[0]?.id)
+      }
+    })
+  })
+  onCleanup(unsub)
+
+  const meta = { migrated: false }
+
+  createEffect(() => {
+    if (!ready()) return
+    if (meta.migrated) return
+    meta.migrated = true
+
+    setStore("all", (all) => {
+      const next = all.map((pty) => {
+        const direct = Number.isFinite(pty.titleNumber) && pty.titleNumber > 0 ? pty.titleNumber : undefined
+        if (direct !== undefined) return pty
+        const parsed = numberFromTitle(pty.title)
+        if (parsed === undefined) return pty
+        return { ...pty, titleNumber: parsed }
+      })
+      if (next.every((pty, index) => pty === all[index])) return all
+      return next
+    })
+  })
+
+  return {
+    ready,
+    all: createMemo(() => Object.values(store.all)),
+    active: createMemo(() => store.active),
+    new() {
+      const existingTitleNumbers = new Set(
+        store.all.flatMap((pty) => {
+          const direct = Number.isFinite(pty.titleNumber) && pty.titleNumber > 0 ? pty.titleNumber : undefined
+          if (direct !== undefined) return [direct]
+          const parsed = numberFromTitle(pty.title)
+          if (parsed === undefined) return []
+          return [parsed]
+        }),
+      )
+
+      const nextNumber =
+        Array.from({ length: existingTitleNumbers.size + 1 }, (_, index) => index + 1).find(
+          (number) => !existingTitleNumbers.has(number),
+        ) ?? 1
+
+      sdk.client.pty
+        .create({ title: `Terminal ${nextNumber}` })
+        .then((pty) => {
+          const id = pty.data?.id
+          if (!id) return
+          const newTerminal = {
+            id,
+            title: pty.data?.title ?? "Terminal",
+            titleNumber: nextNumber,
+          }
+          setStore("all", (all) => {
+            const newAll = [...all, newTerminal]
+            return newAll
+          })
+          setStore("active", id)
+        })
+        .catch((e) => {
+          console.error("Failed to create terminal", e)
+        })
+    },
+    update(pty: Partial<LocalPTY> & { id: string }) {
+      const index = store.all.findIndex((x) => x.id === pty.id)
+      if (index !== -1) {
+        setStore("all", index, (existing) => ({ ...existing, ...pty }))
+      }
+      sdk.client.pty
+        .update({
+          ptyID: pty.id,
+          title: pty.title,
+          size: pty.cols && pty.rows ? { rows: pty.rows, cols: pty.cols } : undefined,
+        })
+        .catch((e) => {
+          console.error("Failed to update terminal", e)
+        })
+    },
+    async clone(id: string) {
+      const index = store.all.findIndex((x) => x.id === id)
+      const pty = store.all[index]
+      if (!pty) return
+      const clone = await sdk.client.pty
+        .create({
+          title: pty.title,
+        })
+        .catch((e) => {
+          console.error("Failed to clone terminal", e)
+          return undefined
+        })
+      if (!clone?.data) return
+      setStore("all", index, {
+        ...pty,
+        ...clone.data,
+      })
+      if (store.active === pty.id) {
+        setStore("active", clone.data.id)
+      }
+    },
+    open(id: string) {
+      setStore("active", id)
+    },
+    next() {
+      const index = store.all.findIndex((x) => x.id === store.active)
+      if (index === -1) return
+      const nextIndex = (index + 1) % store.all.length
+      setStore("active", store.all[nextIndex]?.id)
+    },
+    previous() {
+      const index = store.all.findIndex((x) => x.id === store.active)
+      if (index === -1) return
+      const prevIndex = index === 0 ? store.all.length - 1 : index - 1
+      setStore("active", store.all[prevIndex]?.id)
+    },
+    async close(id: string) {
+      batch(() => {
+        const filtered = store.all.filter((x) => x.id !== id)
+        if (store.active === id) {
+          const index = store.all.findIndex((f) => f.id === id)
+          const next = index > 0 ? index - 1 : 0
+          setStore("active", filtered[next]?.id)
+        }
+        setStore("all", filtered)
+      })
+
+      await sdk.client.pty.remove({ ptyID: id }).catch((e) => {
+        console.error("Failed to close terminal", e)
+      })
+    },
+    move(id: string, to: number) {
+      const index = store.all.findIndex((f) => f.id === id)
+      if (index === -1) return
+      setStore(
+        "all",
+        produce((all) => {
+          all.splice(to, 0, all.splice(index, 1)[0])
+        }),
+      )
+    },
+  }
+}
+
+export const { use: useTerminal, provider: TerminalProvider } = createSimpleContext({
+  name: "Terminal",
+  gate: false,
+  init: () => {
+    const sdk = useSDK()
+    const params = useParams()
+    const cache = new Map<string, TerminalCacheEntry>()
+
+    const disposeAll = () => {
+      for (const entry of cache.values()) {
+        entry.dispose()
+      }
+      cache.clear()
+    }
+
+    onCleanup(disposeAll)
+
+    const prune = () => {
+      while (cache.size > MAX_TERMINAL_SESSIONS) {
+        const first = cache.keys().next().value
+        if (!first) return
+        const entry = cache.get(first)
+        entry?.dispose()
+        cache.delete(first)
+      }
+    }
+
+    const load = (dir: string, session?: string) => {
+      const key = `${dir}:${WORKSPACE_KEY}`
+      const existing = cache.get(key)
+      if (existing) {
+        cache.delete(key)
+        cache.set(key, existing)
+        return existing.value
+      }
+
+      const entry = createRoot((dispose) => ({
+        value: createTerminalSession(sdk, dir, session),
+        dispose,
+      }))
+
+      cache.set(key, entry)
+      prune()
+      return entry.value
+    }
+
+    const workspace = createMemo(() => load(params.dir!, params.id))
+
+    return {
+      ready: () => workspace().ready(),
+      all: () => workspace().all(),
+      active: () => workspace().active(),
+      new: () => workspace().new(),
+      update: (pty: Partial<LocalPTY> & { id: string }) => workspace().update(pty),
+      clone: (id: string) => workspace().clone(id),
+      open: (id: string) => workspace().open(id),
+      close: (id: string) => workspace().close(id),
+      move: (id: string, to: number) => workspace().move(id, to),
+      next: () => workspace().next(),
+      previous: () => workspace().previous(),
+    }
+  },
+})

package/src/custom-elements.d.ts

@@ -0,0 +1,17 @@
+import { DIFFS_TAG_NAME } from "@pierre/diffs"
+
+/**
+ * TypeScript declaration for the <diffs-container> custom element.
+ * This tells TypeScript that <diffs-container> is a valid JSX element in SolidJS.
+ * Required for using the @pierre/diffs web component in .tsx files.
+ */
+
+declare module "solid-js" {
+  namespace JSX {
+    interface IntrinsicElements {
+      [DIFFS_TAG_NAME]: HTMLAttributes<HTMLElement>
+    }
+  }
+}
+
+export {}

package/src/entry.tsx

@@ -0,0 +1,76 @@
+// @refresh reload
+import { render } from "solid-js/web"
+import { AppBaseProviders, AppInterface } from "@/app"
+import { Platform, PlatformProvider } from "@/context/platform"
+import { dict as en } from "@/i18n/en"
+import { dict as zh } from "@/i18n/zh"
+import pkg from "../package.json"
+
+const root = document.getElementById("root")
+if (import.meta.env.DEV && !(root instanceof HTMLElement)) {
+  const locale = (() => {
+    if (typeof navigator !== "object") return "en" as const
+    const languages = navigator.languages?.length ? navigator.languages : [navigator.language]
+    for (const language of languages) {
+      if (!language) continue
+      if (language.toLowerCase().startsWith("zh")) return "zh" as const
+    }
+    return "en" as const
+  })()
+
+  const key = "error.dev.rootNotFound" as const
+  const message = locale === "zh" ? (zh[key] ?? en[key]) : en[key]
+  throw new Error(message)
+}
+
+const platform: Platform = {
+  platform: "web",
+  version: pkg.version,
+  openLink(url: string) {
+    window.open(url, "_blank")
+  },
+  restart: async () => {
+    window.location.reload()
+  },
+  notify: async (title, description, href) => {
+    if (!("Notification" in window)) return
+
+    const permission =
+      Notification.permission === "default"
+        ? await Notification.requestPermission().catch(() => "denied")
+        : Notification.permission
+
+    if (permission !== "granted") return
+
+    const inView = document.visibilityState === "visible" && document.hasFocus()
+    if (inView) return
+
+    await Promise.resolve()
+      .then(() => {
+        const notification = new Notification(title, {
+          body: description ?? "",
+          icon: "https://jonsoc.com/favicon-96x96-v3.png",
+        })
+        notification.onclick = () => {
+          window.focus()
+          if (href) {
+            window.history.pushState(null, "", href)
+            window.dispatchEvent(new PopStateEvent("popstate"))
+          }
+          notification.close()
+        }
+      })
+      .catch(() => undefined)
+  },
+}
+
+render(
+  () => (
+    <PlatformProvider value={platform}>
+      <AppBaseProviders>
+        <AppInterface />
+      </AppBaseProviders>
+    </PlatformProvider>
+  ),
+  root!,
+)

package/src/env.d.ts

@@ -0,0 +1,8 @@
+interface ImportMetaEnv {
+  readonly VITE_OPENCODE_SERVER_HOST: string
+  readonly VITE_OPENCODE_SERVER_PORT: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}

package/src/hooks/use-providers.ts

@@ -0,0 +1,31 @@
+import { useGlobalSync } from "@/context/global-sync"
+import { base64Decode } from "@jonsoc/util/encode"
+import { useParams } from "@solidjs/router"
+import { createMemo } from "solid-js"
+
+export const popularProviders = ["jonsoc", "anthropic", "github-copilot", "openai", "google", "openrouter", "vercel"]
+
+export function useProviders() {
+  const globalSync = useGlobalSync()
+  const params = useParams()
+  const currentDirectory = createMemo(() => base64Decode(params.dir ?? ""))
+  const providers = createMemo(() => {
+    if (currentDirectory()) {
+      const [projectStore] = globalSync.child(currentDirectory())
+      return projectStore.provider
+    }
+    return globalSync.data.provider
+  })
+  const connected = createMemo(() => providers().all.filter((p) => providers().connected.includes(p.id)))
+  const paid = createMemo(() =>
+    connected().filter((p) => p.id !== "jonsoc" || Object.values(p.models).find((m) => m.cost?.input)),
+  )
+  const popular = createMemo(() => providers().all.filter((p) => popularProviders.includes(p.id)))
+  return {
+    all: createMemo(() => providers().all),
+    default: createMemo(() => providers().default),
+    popular,
+    connected,
+    paid,
+  }
+}