@jonsoc/app 1.1.34

package/src/context/notification.tsx

@@ -0,0 +1,173 @@
+import { createStore } from "solid-js/store"
+import { createEffect, onCleanup } from "solid-js"
+import { useParams } from "@solidjs/router"
+import { createSimpleContext } from "@jonsoc/ui/context"
+import { useGlobalSDK } from "./global-sdk"
+import { useGlobalSync } from "./global-sync"
+import { usePlatform } from "@/context/platform"
+import { useLanguage } from "@/context/language"
+import { useSettings } from "@/context/settings"
+import { Binary } from "@jonsoc/util/binary"
+import { base64Decode, base64Encode } from "@jonsoc/util/encode"
+import { EventSessionError } from "@jonsoc/sdk/v2"
+import { Persist, persisted } from "@/utils/persist"
+import { playSound, soundSrc } from "@/utils/sound"
+
+type NotificationBase = {
+  directory?: string
+  session?: string
+  metadata?: any
+  time: number
+  viewed: boolean
+}
+
+type TurnCompleteNotification = NotificationBase & {
+  type: "turn-complete"
+}
+
+type ErrorNotification = NotificationBase & {
+  type: "error"
+  error: EventSessionError["properties"]["error"]
+}
+
+export type Notification = TurnCompleteNotification | ErrorNotification
+
+const MAX_NOTIFICATIONS = 500
+const NOTIFICATION_TTL_MS = 1000 * 60 * 60 * 24 * 30
+
+function pruneNotifications(list: Notification[]) {
+  const cutoff = Date.now() - NOTIFICATION_TTL_MS
+  const pruned = list.filter((n) => n.time >= cutoff)
+  if (pruned.length <= MAX_NOTIFICATIONS) return pruned
+  return pruned.slice(pruned.length - MAX_NOTIFICATIONS)
+}
+
+export const { use: useNotification, provider: NotificationProvider } = createSimpleContext({
+  name: "Notification",
+  init: () => {
+    const params = useParams()
+    const globalSDK = useGlobalSDK()
+    const globalSync = useGlobalSync()
+    const platform = usePlatform()
+    const settings = useSettings()
+    const language = useLanguage()
+
+    const [store, setStore, _, ready] = persisted(
+      Persist.global("notification", ["notification.v1"]),
+      createStore({
+        list: [] as Notification[],
+      }),
+    )
+
+    const meta = { pruned: false }
+
+    createEffect(() => {
+      if (!ready()) return
+      if (meta.pruned) return
+      meta.pruned = true
+      setStore("list", pruneNotifications(store.list))
+    })
+
+    const append = (notification: Notification) => {
+      setStore("list", (list) => pruneNotifications([...list, notification]))
+    }
+
+    const unsub = globalSDK.event.listen((e) => {
+      const directory = e.name
+      const event = e.details
+      const time = Date.now()
+      const activeDirectory = params.dir ? base64Decode(params.dir) : undefined
+      const activeSession = params.id
+      const viewed = (sessionID?: string) => {
+        if (!activeDirectory) return false
+        if (!activeSession) return false
+        if (!sessionID) return false
+        if (directory !== activeDirectory) return false
+        return sessionID === activeSession
+      }
+      switch (event.type) {
+        case "session.idle": {
+          const sessionID = event.properties.sessionID
+          const [syncStore] = globalSync.child(directory)
+          const match = Binary.search(syncStore.session, sessionID, (s) => s.id)
+          const session = match.found ? syncStore.session[match.index] : undefined
+          if (session?.parentID) break
+
+          playSound(soundSrc(settings.sounds.agent()))
+
+          append({
+            directory,
+            time,
+            viewed: viewed(sessionID),
+            type: "turn-complete",
+            session: sessionID,
+          })
+
+          const href = `/${base64Encode(directory)}/session/${sessionID}`
+          if (settings.notifications.agent()) {
+            void platform.notify(
+              language.t("notification.session.responseReady.title"),
+              session?.title ?? sessionID,
+              href,
+            )
+          }
+          break
+        }
+        case "session.error": {
+          const sessionID = event.properties.sessionID
+          const [syncStore] = globalSync.child(directory)
+          const match = sessionID ? Binary.search(syncStore.session, sessionID, (s) => s.id) : undefined
+          const session = sessionID && match?.found ? syncStore.session[match.index] : undefined
+          if (session?.parentID) break
+
+          playSound(soundSrc(settings.sounds.errors()))
+
+          const error = "error" in event.properties ? event.properties.error : undefined
+          append({
+            directory,
+            time,
+            viewed: viewed(sessionID),
+            type: "error",
+            session: sessionID ?? "global",
+            error,
+          })
+          const description =
+            session?.title ??
+            (typeof error === "string" ? error : language.t("notification.session.error.fallbackDescription"))
+          const href = sessionID ? `/${base64Encode(directory)}/session/${sessionID}` : `/${base64Encode(directory)}`
+          if (settings.notifications.errors()) {
+            void platform.notify(language.t("notification.session.error.title"), description, href)
+          }
+          break
+        }
+      }
+    })
+    onCleanup(unsub)
+
+    return {
+      ready,
+      session: {
+        all(session: string) {
+          return store.list.filter((n) => n.session === session)
+        },
+        unseen(session: string) {
+          return store.list.filter((n) => n.session === session && !n.viewed)
+        },
+        markViewed(session: string) {
+          setStore("list", (n) => n.session === session, "viewed", true)
+        },
+      },
+      project: {
+        all(directory: string) {
+          return store.list.filter((n) => n.directory === directory)
+        },
+        unseen(directory: string) {
+          return store.list.filter((n) => n.directory === directory && !n.viewed)
+        },
+        markViewed(directory: string) {
+          setStore("list", (n) => n.directory === directory, "viewed", true)
+        },
+      },
+    }
+  },
+})

package/src/context/permission.tsx

@@ -0,0 +1,167 @@
+import { createMemo, onCleanup } from "solid-js"
+import { createStore, produce } from "solid-js/store"
+import { createSimpleContext } from "@jonsoc/ui/context"
+import type { PermissionRequest } from "@jonsoc/sdk/v2/client"
+import { Persist, persisted } from "@/utils/persist"
+import { useGlobalSDK } from "@/context/global-sdk"
+import { useGlobalSync } from "./global-sync"
+import { useParams } from "@solidjs/router"
+import { base64Decode, base64Encode } from "@jonsoc/util/encode"
+
+type PermissionRespondFn = (input: {
+  sessionID: string
+  permissionID: string
+  response: "once" | "always" | "reject"
+  directory?: string
+}) => void
+
+function shouldAutoAccept(perm: PermissionRequest) {
+  return perm.permission === "edit"
+}
+
+function isNonAllowRule(rule: unknown) {
+  if (!rule) return false
+  if (typeof rule === "string") return rule !== "allow"
+  if (typeof rule !== "object") return false
+  if (Array.isArray(rule)) return false
+
+  for (const action of Object.values(rule)) {
+    if (action !== "allow") return true
+  }
+
+  return false
+}
+
+function hasAutoAcceptPermissionConfig(permission: unknown) {
+  if (!permission) return false
+  if (typeof permission === "string") return permission !== "allow"
+  if (typeof permission !== "object") return false
+  if (Array.isArray(permission)) return false
+
+  const config = permission as Record<string, unknown>
+  if (isNonAllowRule(config.edit)) return true
+  if (isNonAllowRule(config.write)) return true
+
+  return false
+}
+
+export const { use: usePermission, provider: PermissionProvider } = createSimpleContext({
+  name: "Permission",
+  init: () => {
+    const params = useParams()
+    const globalSDK = useGlobalSDK()
+    const globalSync = useGlobalSync()
+
+    const permissionsEnabled = createMemo(() => {
+      const directory = params.dir ? base64Decode(params.dir) : undefined
+      if (!directory) return false
+      const [store] = globalSync.child(directory)
+      return hasAutoAcceptPermissionConfig(store.config.permission)
+    })
+
+    const [store, setStore, _, ready] = persisted(
+      Persist.global("permission", ["permission.v3"]),
+      createStore({
+        autoAcceptEdits: {} as Record<string, boolean>,
+      }),
+    )
+
+    const responded = new Set<string>()
+
+    const respond: PermissionRespondFn = (input) => {
+      globalSDK.client.permission.respond(input).catch(() => {
+        responded.delete(input.permissionID)
+      })
+    }
+
+    function respondOnce(permission: PermissionRequest, directory?: string) {
+      if (responded.has(permission.id)) return
+      responded.add(permission.id)
+      respond({
+        sessionID: permission.sessionID,
+        permissionID: permission.id,
+        response: "once",
+        directory,
+      })
+    }
+
+    function acceptKey(sessionID: string, directory?: string) {
+      if (!directory) return sessionID
+      return `${base64Encode(directory)}/${sessionID}`
+    }
+
+    function isAutoAccepting(sessionID: string, directory?: string) {
+      const key = acceptKey(sessionID, directory)
+      return store.autoAcceptEdits[key] ?? store.autoAcceptEdits[sessionID] ?? false
+    }
+
+    const unsubscribe = globalSDK.event.listen((e) => {
+      const event = e.details
+      if (event?.type !== "permission.asked") return
+
+      const perm = event.properties
+      if (!isAutoAccepting(perm.sessionID, e.name)) return
+      if (!shouldAutoAccept(perm)) return
+
+      respondOnce(perm, e.name)
+    })
+    onCleanup(unsubscribe)
+
+    function enable(sessionID: string, directory: string) {
+      const key = acceptKey(sessionID, directory)
+      setStore(
+        produce((draft) => {
+          draft.autoAcceptEdits[key] = true
+          delete draft.autoAcceptEdits[sessionID]
+        }),
+      )
+
+      globalSDK.client.permission
+        .list({ directory })
+        .then((x) => {
+          for (const perm of x.data ?? []) {
+            if (!perm?.id) continue
+            if (perm.sessionID !== sessionID) continue
+            if (!shouldAutoAccept(perm)) continue
+            respondOnce(perm, directory)
+          }
+        })
+        .catch(() => undefined)
+    }
+
+    function disable(sessionID: string, directory?: string) {
+      const key = directory ? acceptKey(sessionID, directory) : undefined
+      setStore(
+        produce((draft) => {
+          if (key) delete draft.autoAcceptEdits[key]
+          delete draft.autoAcceptEdits[sessionID]
+        }),
+      )
+    }
+
+    return {
+      ready,
+      respond,
+      autoResponds(permission: PermissionRequest, directory?: string) {
+        return isAutoAccepting(permission.sessionID, directory) && shouldAutoAccept(permission)
+      },
+      isAutoAccepting,
+      toggleAutoAccept(sessionID: string, directory: string) {
+        if (isAutoAccepting(sessionID, directory)) {
+          disable(sessionID, directory)
+          return
+        }
+
+        enable(sessionID, directory)
+      },
+      enableAutoAccept(sessionID: string, directory: string) {
+        if (isAutoAccepting(sessionID, directory)) return
+        enable(sessionID, directory)
+      },
+      disableAutoAccept(sessionID: string, directory?: string) {
+        disable(sessionID, directory)
+      },
+      permissionsEnabled,
+    }
+  },
+})

package/src/context/platform.tsx

@@ -0,0 +1,59 @@
+import { createSimpleContext } from "@jonsoc/ui/context"
+import { AsyncStorage, SyncStorage } from "@solid-primitives/storage"
+
+export type Platform = {
+  /** Platform discriminator */
+  platform: "web" | "desktop"
+
+  /** Desktop OS (Tauri only) */
+  os?: "macos" | "windows" | "linux"
+
+  /** App version */
+  version?: string
+
+  /** Open a URL in the default browser */
+  openLink(url: string): void
+
+  /** Restart the app  */
+  restart(): Promise<void>
+
+  /** Send a system notification (optional deep link) */
+  notify(title: string, description?: string, href?: string): Promise<void>
+
+  /** Open directory picker dialog (native on Tauri, server-backed on web) */
+  openDirectoryPickerDialog?(opts?: { title?: string; multiple?: boolean }): Promise<string | string[] | null>
+
+  /** Open native file picker dialog (Tauri only) */
+  openFilePickerDialog?(opts?: { title?: string; multiple?: boolean }): Promise<string | string[] | null>
+
+  /** Save file picker dialog (Tauri only) */
+  saveFilePickerDialog?(opts?: { title?: string; defaultPath?: string }): Promise<string | null>
+
+  /** Storage mechanism, defaults to localStorage */
+  storage?: (name?: string) => SyncStorage | AsyncStorage
+
+  /** Check for updates (Tauri only) */
+  checkUpdate?(): Promise<{ updateAvailable: boolean; version?: string }>
+
+  /** Install updates (Tauri only) */
+  update?(): Promise<void>
+
+  /** Fetch override */
+  fetch?: typeof fetch
+
+  /** Get the configured default server URL (desktop only) */
+  getDefaultServerUrl?(): Promise<string | null>
+
+  /** Set the default server URL to use on app startup (desktop only) */
+  setDefaultServerUrl?(url: string | null): Promise<void>
+
+  /** Parse markdown to HTML using native parser (desktop only, returns unprocessed code blocks) */
+  parseMarkdown?(markdown: string): Promise<string>
+}
+
+export const { use: usePlatform, provider: PlatformProvider } = createSimpleContext({
+  name: "Platform",
+  init: (props: { value: Platform }) => {
+    return props.value
+  },
+})

package/src/context/prompt.tsx

@@ -0,0 +1,245 @@
+import { createStore } from "solid-js/store"
+import { createSimpleContext } from "@jonsoc/ui/context"
+import { batch, createMemo, createRoot, onCleanup } from "solid-js"
+import { useParams } from "@solidjs/router"
+import type { FileSelection } from "@/context/file"
+import { Persist, persisted } from "@/utils/persist"
+import { checksum } from "@jonsoc/util/encode"
+
+interface PartBase {
+  content: string
+  start: number
+  end: number
+}
+
+export interface TextPart extends PartBase {
+  type: "text"
+}
+
+export interface FileAttachmentPart extends PartBase {
+  type: "file"
+  path: string
+  selection?: FileSelection
+}
+
+export interface AgentPart extends PartBase {
+  type: "agent"
+  name: string
+}
+
+export interface ImageAttachmentPart {
+  type: "image"
+  id: string
+  filename: string
+  mime: string
+  dataUrl: string
+}
+
+export type ContentPart = TextPart | FileAttachmentPart | AgentPart | ImageAttachmentPart
+export type Prompt = ContentPart[]
+
+export type FileContextItem = {
+  type: "file"
+  path: string
+  selection?: FileSelection
+  comment?: string
+  commentID?: string
+  preview?: string
+}
+
+export type ContextItem = FileContextItem
+
+export const DEFAULT_PROMPT: Prompt = [{ type: "text", content: "", start: 0, end: 0 }]
+
+function isSelectionEqual(a?: FileSelection, b?: FileSelection) {
+  if (!a && !b) return true
+  if (!a || !b) return false
+  return (
+    a.startLine === b.startLine && a.startChar === b.startChar && a.endLine === b.endLine && a.endChar === b.endChar
+  )
+}
+
+export function isPromptEqual(promptA: Prompt, promptB: Prompt): boolean {
+  if (promptA.length !== promptB.length) return false
+  for (let i = 0; i < promptA.length; i++) {
+    const partA = promptA[i]
+    const partB = promptB[i]
+    if (partA.type !== partB.type) return false
+    if (partA.type === "text" && partA.content !== (partB as TextPart).content) {
+      return false
+    }
+    if (partA.type === "file") {
+      const fileA = partA as FileAttachmentPart
+      const fileB = partB as FileAttachmentPart
+      if (fileA.path !== fileB.path) return false
+      if (!isSelectionEqual(fileA.selection, fileB.selection)) return false
+    }
+    if (partA.type === "agent" && partA.name !== (partB as AgentPart).name) {
+      return false
+    }
+    if (partA.type === "image" && partA.id !== (partB as ImageAttachmentPart).id) {
+      return false
+    }
+  }
+  return true
+}
+
+function cloneSelection(selection?: FileSelection) {
+  if (!selection) return undefined
+  return { ...selection }
+}
+
+function clonePart(part: ContentPart): ContentPart {
+  if (part.type === "text") return { ...part }
+  if (part.type === "image") return { ...part }
+  if (part.type === "agent") return { ...part }
+  return {
+    ...part,
+    selection: cloneSelection(part.selection),
+  }
+}
+
+function clonePrompt(prompt: Prompt): Prompt {
+  return prompt.map(clonePart)
+}
+
+const WORKSPACE_KEY = "__workspace__"
+const MAX_PROMPT_SESSIONS = 20
+
+type PromptSession = ReturnType<typeof createPromptSession>
+
+type PromptCacheEntry = {
+  value: PromptSession
+  dispose: VoidFunction
+}
+
+function createPromptSession(dir: string, id: string | undefined) {
+  const legacy = `${dir}/prompt${id ? "/" + id : ""}.v2`
+
+  const [store, setStore, _, ready] = persisted(
+    Persist.scoped(dir, id, "prompt", [legacy]),
+    createStore<{
+      prompt: Prompt
+      cursor?: number
+      context: {
+        items: (ContextItem & { key: string })[]
+      }
+    }>({
+      prompt: clonePrompt(DEFAULT_PROMPT),
+      cursor: undefined,
+      context: {
+        items: [],
+      },
+    }),
+  )
+
+  function keyForItem(item: ContextItem) {
+    if (item.type !== "file") return item.type
+    const start = item.selection?.startLine
+    const end = item.selection?.endLine
+    const key = `${item.type}:${item.path}:${start}:${end}`
+
+    if (item.commentID) {
+      return `${key}:c=${item.commentID}`
+    }
+
+    const comment = item.comment?.trim()
+    if (!comment) return key
+    const digest = checksum(comment) ?? comment
+    return `${key}:c=${digest.slice(0, 8)}`
+  }
+
+  return {
+    ready,
+    current: createMemo(() => store.prompt),
+    cursor: createMemo(() => store.cursor),
+    dirty: createMemo(() => !isPromptEqual(store.prompt, DEFAULT_PROMPT)),
+    context: {
+      items: createMemo(() => store.context.items),
+      add(item: ContextItem) {
+        const key = keyForItem(item)
+        if (store.context.items.find((x) => x.key === key)) return
+        setStore("context", "items", (items) => [...items, { key, ...item }])
+      },
+      remove(key: string) {
+        setStore("context", "items", (items) => items.filter((x) => x.key !== key))
+      },
+    },
+    set(prompt: Prompt, cursorPosition?: number) {
+      const next = clonePrompt(prompt)
+      batch(() => {
+        setStore("prompt", next)
+        if (cursorPosition !== undefined) setStore("cursor", cursorPosition)
+      })
+    },
+    reset() {
+      batch(() => {
+        setStore("prompt", clonePrompt(DEFAULT_PROMPT))
+        setStore("cursor", 0)
+      })
+    },
+  }
+}
+
+export const { use: usePrompt, provider: PromptProvider } = createSimpleContext({
+  name: "Prompt",
+  gate: false,
+  init: () => {
+    const params = useParams()
+    const cache = new Map<string, PromptCacheEntry>()
+
+    const disposeAll = () => {
+      for (const entry of cache.values()) {
+        entry.dispose()
+      }
+      cache.clear()
+    }
+
+    onCleanup(disposeAll)
+
+    const prune = () => {
+      while (cache.size > MAX_PROMPT_SESSIONS) {
+        const first = cache.keys().next().value
+        if (!first) return
+        const entry = cache.get(first)
+        entry?.dispose()
+        cache.delete(first)
+      }
+    }
+
+    const load = (dir: string, id: string | undefined) => {
+      const key = `${dir}:${id ?? WORKSPACE_KEY}`
+      const existing = cache.get(key)
+      if (existing) {
+        cache.delete(key)
+        cache.set(key, existing)
+        return existing.value
+      }
+
+      const entry = createRoot((dispose) => ({
+        value: createPromptSession(dir, id),
+        dispose,
+      }))
+
+      cache.set(key, entry)
+      prune()
+      return entry.value
+    }
+
+    const session = createMemo(() => load(params.dir!, params.id))
+
+    return {
+      ready: () => session().ready(),
+      current: () => session().current(),
+      cursor: () => session().cursor(),
+      dirty: () => session().dirty(),
+      context: {
+        items: () => session().context.items(),
+        add: (item: ContextItem) => session().context.add(item),
+        remove: (key: string) => session().context.remove(key),
+      },
+      set: (prompt: Prompt, cursorPosition?: number) => session().set(prompt, cursorPosition),
+      reset: () => session().reset(),
+    }
+  },
+})

package/src/context/sdk.tsx

@@ -0,0 +1,48 @@
+import { createOpencodeClient, type Event } from "@jonsoc/sdk/v2/client"
+import { createSimpleContext } from "@jonsoc/ui/context"
+import { createGlobalEmitter } from "@solid-primitives/event-bus"
+import { createEffect, createMemo, onCleanup } from "solid-js"
+import { useGlobalSDK } from "./global-sdk"
+import { usePlatform } from "./platform"
+
+export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
+  name: "SDK",
+  init: (props: { directory: string }) => {
+    const platform = usePlatform()
+    const globalSDK = useGlobalSDK()
+
+    const directory = createMemo(() => props.directory)
+    const client = createMemo(() =>
+      createOpencodeClient({
+        baseUrl: globalSDK.url,
+        fetch: platform.fetch,
+        directory: directory(),
+        throwOnError: true,
+      }),
+    )
+
+    const emitter = createGlobalEmitter<{
+      [key in Event["type"]]: Extract<Event, { type: key }>
+    }>()
+
+    createEffect(() => {
+      const unsub = globalSDK.event.on(directory(), (event) => {
+        emitter.emit(event.type, event)
+      })
+      onCleanup(unsub)
+    })
+
+    return {
+      get directory() {
+        return directory()
+      },
+      get client() {
+        return client()
+      },
+      event: emitter,
+      get url() {
+        return globalSDK.url
+      },
+    }
+  },
+})