reigncode-app 1.3.2

package/src/utils/runtime-adapters.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test"
+import {
+  disposeIfDisposable,
+  getHoveredLinkText,
+  getSpeechRecognitionCtor,
+  hasSetOption,
+  isDisposable,
+  setOptionIfSupported,
+} from "./runtime-adapters"
+
+describe("runtime adapters", () => {
+  test("detects and disposes disposable values", () => {
+    let count = 0
+    const value = {
+      dispose: () => {
+        count += 1
+      },
+    }
+    expect(isDisposable(value)).toBe(true)
+    disposeIfDisposable(value)
+    expect(count).toBe(1)
+  })
+
+  test("ignores non-disposable values", () => {
+    expect(isDisposable({ dispose: "nope" })).toBe(false)
+    expect(() => disposeIfDisposable({ dispose: "nope" })).not.toThrow()
+  })
+
+  test("sets options only when setter exists", () => {
+    const calls: Array<[string, unknown]> = []
+    const value = {
+      setOption: (key: string, next: unknown) => {
+        calls.push([key, next])
+      },
+    }
+    expect(hasSetOption(value)).toBe(true)
+    setOptionIfSupported(value, "fontFamily", "Berkeley Mono")
+    expect(calls).toEqual([["fontFamily", "Berkeley Mono"]])
+    expect(() => setOptionIfSupported({}, "fontFamily", "Berkeley Mono")).not.toThrow()
+  })
+
+  test("reads hovered link text safely", () => {
+    expect(getHoveredLinkText({ currentHoveredLink: { text: "https://example.com" } })).toBe("https://example.com")
+    expect(getHoveredLinkText({ currentHoveredLink: { text: 1 } })).toBeUndefined()
+    expect(getHoveredLinkText(null)).toBeUndefined()
+  })
+
+  test("resolves speech recognition constructor with webkit precedence", () => {
+    class SpeechCtor {}
+    class WebkitCtor {}
+    const ctor = getSpeechRecognitionCtor({
+      SpeechRecognition: SpeechCtor,
+      webkitSpeechRecognition: WebkitCtor,
+    })
+    expect(ctor).toBe(WebkitCtor)
+  })
+
+  test("returns undefined when no valid speech constructor exists", () => {
+    expect(getSpeechRecognitionCtor({ SpeechRecognition: "nope" })).toBeUndefined()
+    expect(getSpeechRecognitionCtor(undefined)).toBeUndefined()
+  })
+})

package/src/utils/runtime-adapters.ts

@@ -0,0 +1,39 @@
+type RecordValue = Record<string, unknown>
+
+const isRecord = (value: unknown): value is RecordValue => {
+  return typeof value === "object" && value !== null
+}
+
+export const isDisposable = (value: unknown): value is { dispose: () => void } => {
+  return isRecord(value) && typeof value.dispose === "function"
+}
+
+export const disposeIfDisposable = (value: unknown) => {
+  if (!isDisposable(value)) return
+  value.dispose()
+}
+
+export const hasSetOption = (value: unknown): value is { setOption: (key: string, next: unknown) => void } => {
+  return isRecord(value) && typeof value.setOption === "function"
+}
+
+export const setOptionIfSupported = (value: unknown, key: string, next: unknown) => {
+  if (!hasSetOption(value)) return
+  value.setOption(key, next)
+}
+
+export const getHoveredLinkText = (value: unknown) => {
+  if (!isRecord(value)) return
+  const link = value.currentHoveredLink
+  if (!isRecord(link)) return
+  if (typeof link.text !== "string") return
+  return link.text
+}
+
+export const getSpeechRecognitionCtor = <T>(value: unknown): (new () => T) | undefined => {
+  if (!isRecord(value)) return
+  const ctor =
+    typeof value.webkitSpeechRecognition === "function" ? value.webkitSpeechRecognition : value.SpeechRecognition
+  if (typeof ctor !== "function") return
+  return ctor as new () => T
+}

package/src/utils/same.ts

@@ -0,0 +1,6 @@
+export function same<T>(a: readonly T[] | undefined, b: readonly T[] | undefined) {
+  if (a === b) return true
+  if (!a || !b) return false
+  if (a.length !== b.length) return false
+  return a.every((x, i) => x === b[i])
+}

package/src/utils/scoped-cache.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test"
+import { createScopedCache } from "./scoped-cache"
+
+describe("createScopedCache", () => {
+  test("evicts least-recently-used entry when max is reached", () => {
+    const disposed: string[] = []
+    const cache = createScopedCache((key) => ({ key }), {
+      maxEntries: 2,
+      dispose: (value) => disposed.push(value.key),
+    })
+
+    const a = cache.get("a")
+    const b = cache.get("b")
+    expect(a.key).toBe("a")
+    expect(b.key).toBe("b")
+
+    cache.get("a")
+    const c = cache.get("c")
+
+    expect(c.key).toBe("c")
+    expect(cache.peek("a")?.key).toBe("a")
+    expect(cache.peek("b")).toBeUndefined()
+    expect(cache.peek("c")?.key).toBe("c")
+    expect(disposed).toEqual(["b"])
+  })
+
+  test("disposes entries on delete and clear", () => {
+    const disposed: string[] = []
+    const cache = createScopedCache((key) => ({ key }), {
+      dispose: (value) => disposed.push(value.key),
+    })
+
+    cache.get("a")
+    cache.get("b")
+
+    const removed = cache.delete("a")
+    expect(removed?.key).toBe("a")
+    expect(cache.peek("a")).toBeUndefined()
+
+    cache.clear()
+    expect(cache.peek("b")).toBeUndefined()
+    expect(disposed).toEqual(["a", "b"])
+  })
+
+  test("expires stale entries with ttl and recreates on get", () => {
+    let clock = 0
+    let count = 0
+    const disposed: string[] = []
+    const cache = createScopedCache((key) => ({ key, count: ++count }), {
+      ttlMs: 10,
+      now: () => clock,
+      dispose: (value) => disposed.push(`${value.key}:${value.count}`),
+    })
+
+    const first = cache.get("a")
+    expect(first.count).toBe(1)
+
+    clock = 9
+    expect(cache.peek("a")?.count).toBe(1)
+
+    clock = 11
+    expect(cache.peek("a")).toBeUndefined()
+    expect(disposed).toEqual(["a:1"])
+
+    const second = cache.get("a")
+    expect(second.count).toBe(2)
+    expect(disposed).toEqual(["a:1"])
+  })
+})

package/src/utils/scoped-cache.ts

@@ -0,0 +1,104 @@
+type ScopedCacheOptions<T> = {
+  maxEntries?: number
+  ttlMs?: number
+  dispose?: (value: T, key: string) => void
+  now?: () => number
+}
+
+type Entry<T> = {
+  value: T
+  touchedAt: number
+}
+
+export function createScopedCache<T>(createValue: (key: string) => T, options: ScopedCacheOptions<T> = {}) {
+  const store = new Map<string, Entry<T>>()
+  const now = options.now ?? Date.now
+
+  const dispose = (key: string, entry: Entry<T>) => {
+    options.dispose?.(entry.value, key)
+  }
+
+  const expired = (entry: Entry<T>) => {
+    if (options.ttlMs === undefined) return false
+    return now() - entry.touchedAt >= options.ttlMs
+  }
+
+  const sweep = () => {
+    if (options.ttlMs === undefined) return
+    for (const [key, entry] of store) {
+      if (!expired(entry)) continue
+      store.delete(key)
+      dispose(key, entry)
+    }
+  }
+
+  const touch = (key: string, entry: Entry<T>) => {
+    entry.touchedAt = now()
+    store.delete(key)
+    store.set(key, entry)
+  }
+
+  const prune = () => {
+    if (options.maxEntries === undefined) return
+    while (store.size > options.maxEntries) {
+      const key = store.keys().next().value
+      if (!key) return
+      const entry = store.get(key)
+      store.delete(key)
+      if (!entry) continue
+      dispose(key, entry)
+    }
+  }
+
+  const remove = (key: string) => {
+    const entry = store.get(key)
+    if (!entry) return
+    store.delete(key)
+    dispose(key, entry)
+    return entry.value
+  }
+
+  const peek = (key: string) => {
+    sweep()
+    const entry = store.get(key)
+    if (!entry) return
+    if (!expired(entry)) return entry.value
+    store.delete(key)
+    dispose(key, entry)
+  }
+
+  const get = (key: string) => {
+    sweep()
+    const entry = store.get(key)
+    if (entry && !expired(entry)) {
+      touch(key, entry)
+      return entry.value
+    }
+    if (entry) {
+      store.delete(key)
+      dispose(key, entry)
+    }
+
+    const created = {
+      value: createValue(key),
+      touchedAt: now(),
+    }
+    store.set(key, created)
+    prune()
+    return created.value
+  }
+
+  const clear = () => {
+    for (const [key, entry] of store) {
+      dispose(key, entry)
+    }
+    store.clear()
+  }
+
+  return {
+    get,
+    peek,
+    delete: remove,
+    clear,
+  }
+}

package/src/utils/server-errors.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "bun:test"
+import type { ConfigInvalidError, ProviderModelNotFoundError } from "./server-errors"
+import { formatServerError, parseReadableConfigInvalidError } from "./server-errors"
+
+function fill(text: string, vars?: Record<string, string | number>) {
+  if (!vars) return text
+  return text.replace(/{{\s*(\w+)\s*}}/g, (_, key: string) => {
+    const value = vars[key]
+    if (value === undefined) return ""
+    return String(value)
+  })
+}
+
+function useLanguageMock() {
+  const dict: Record<string, string> = {
+    "error.chain.unknown": "Erro desconhecido",
+    "error.chain.configInvalid": "Arquivo de config em {{path}} invalido",
+    "error.chain.configInvalidWithMessage": "Arquivo de config em {{path}} invalido: {{message}}",
+    "error.chain.modelNotFound": "Modelo nao encontrado: {{provider}}/{{model}}",
+    "error.chain.didYouMean": "Voce quis dizer: {{suggestions}}",
+    "error.chain.checkConfig": "Revise provider/model no config",
+  }
+  return {
+    t(key: string, vars?: Record<string, string | number>) {
+      const text = dict[key]
+      if (!text) return key
+      return fill(text, vars)
+    },
+  }
+}
+
+const language = useLanguageMock()
+
+describe("parseReadableConfigInvalidError", () => {
+  test("formats issues with file path", () => {
+    const error = {
+      name: "ConfigInvalidError",
+      data: {
+        path: "opencode.config.ts",
+        issues: [
+          { path: ["settings", "host"], message: "Required" },
+          { path: ["mode"], message: "Invalid" },
+        ],
+      },
+    } satisfies ConfigInvalidError
+
+    const result = parseReadableConfigInvalidError(error, language.t)
+
+    expect(result).toBe(
+      ["Arquivo de config em opencode.config.ts invalido: settings.host: Required", "mode: Invalid"].join("\n"),
+    )
+  })
+
+  test("uses trimmed message when issues are missing", () => {
+    const error = {
+      name: "ConfigInvalidError",
+      data: {
+        path: "config",
+        message: "  Bad value  ",
+      },
+    } satisfies ConfigInvalidError
+
+    const result = parseReadableConfigInvalidError(error, language.t)
+
+    expect(result).toBe("Arquivo de config em config invalido: Bad value")
+  })
+})
+
+describe("formatServerError", () => {
+  test("formats config invalid errors", () => {
+    const error = {
+      name: "ConfigInvalidError",
+      data: {
+        message: "Missing host",
+      },
+    } satisfies ConfigInvalidError
+
+    const result = formatServerError(error, language.t)
+
+    expect(result).toBe("Arquivo de config em config invalido: Missing host")
+  })
+
+  test("returns error messages", () => {
+    expect(formatServerError(new Error("Request failed with status 503"), language.t)).toBe(
+      "Request failed with status 503",
+    )
+  })
+
+  test("returns provided string errors", () => {
+    expect(formatServerError("Failed to connect to server", language.t)).toBe("Failed to connect to server")
+  })
+
+  test("uses translated unknown fallback", () => {
+    expect(formatServerError(0, language.t)).toBe("Erro desconhecido")
+  })
+
+  test("falls back for unknown error objects and names", () => {
+    expect(formatServerError({ name: "ServerTimeoutError", data: { seconds: 30 } }, language.t)).toBe(
+      "Erro desconhecido",
+    )
+  })
+
+  test("formats provider model errors using provider/model", () => {
+    const error = {
+      name: "ProviderModelNotFoundError",
+      data: {
+        providerID: "openai",
+        modelID: "gpt-4.1",
+      },
+    } satisfies ProviderModelNotFoundError
+
+    expect(formatServerError(error, language.t)).toBe(
+      ["Modelo nao encontrado: openai/gpt-4.1", "Revise provider/model no config"].join("\n"),
+    )
+  })
+
+  test("formats provider model suggestions", () => {
+    const error = {
+      name: "ProviderModelNotFoundError",
+      data: {
+        providerID: "x",
+        modelID: "y",
+        suggestions: ["x/y2", "x/y3"],
+      },
+    } satisfies ProviderModelNotFoundError
+
+    expect(formatServerError(error, language.t)).toBe(
+      ["Modelo nao encontrado: x/y", "Voce quis dizer: x/y2, x/y3", "Revise provider/model no config"].join("\n"),
+    )
+  })
+})

package/src/utils/server-errors.ts

@@ -0,0 +1,80 @@
+export type ConfigInvalidError = {
+  name: "ConfigInvalidError"
+  data: {
+    path?: string
+    message?: string
+    issues?: Array<{ message: string; path: string[] }>
+  }
+}
+
+export type ProviderModelNotFoundError = {
+  name: "ProviderModelNotFoundError"
+  data: {
+    providerID: string
+    modelID: string
+    suggestions?: string[]
+  }
+}
+
+type Translator = (key: string, vars?: Record<string, string | number>) => string
+
+function tr(translator: Translator | undefined, key: string, text: string, vars?: Record<string, string | number>) {
+  if (!translator) return text
+  const out = translator(key, vars)
+  if (!out || out === key) return text
+  return out
+}
+
+export function formatServerError(error: unknown, translate?: Translator, fallback?: string) {
+  if (isConfigInvalidErrorLike(error)) return parseReadableConfigInvalidError(error, translate)
+  if (isProviderModelNotFoundErrorLike(error)) return parseReadableProviderModelNotFoundError(error, translate)
+  if (error instanceof Error && error.message) return error.message
+  if (typeof error === "string" && error) return error
+  if (fallback) return fallback
+  return tr(translate, "error.chain.unknown", "Unknown error")
+}
+
+function isConfigInvalidErrorLike(error: unknown): error is ConfigInvalidError {
+  if (typeof error !== "object" || error === null) return false
+  const o = error as Record<string, unknown>
+  return o.name === "ConfigInvalidError" && typeof o.data === "object" && o.data !== null
+}
+
+function isProviderModelNotFoundErrorLike(error: unknown): error is ProviderModelNotFoundError {
+  if (typeof error !== "object" || error === null) return false
+  const o = error as Record<string, unknown>
+  return o.name === "ProviderModelNotFoundError" && typeof o.data === "object" && o.data !== null
+}
+
+export function parseReadableConfigInvalidError(errorInput: ConfigInvalidError, translator?: Translator) {
+  const file = errorInput.data.path && errorInput.data.path !== "config" ? errorInput.data.path : "config"
+  const detail = errorInput.data.message?.trim() ?? ""
+  const issues = (errorInput.data.issues ?? [])
+    .map((issue) => {
+      const msg = issue.message.trim()
+      if (!issue.path.length) return msg
+      return `${issue.path.join(".")}: ${msg}`
+    })
+    .filter(Boolean)
+  const msg = issues.length ? issues.join("\n") : detail
+  if (!msg) return tr(translator, "error.chain.configInvalid", `Config file at ${file} is invalid`, { path: file })
+  return tr(translator, "error.chain.configInvalidWithMessage", `Config file at ${file} is invalid: ${msg}`, {
+    path: file,
+    message: msg,
+  })
+}
+
+function parseReadableProviderModelNotFoundError(errorInput: ProviderModelNotFoundError, translator?: Translator) {
+  const p = errorInput.data.providerID.trim()
+  const m = errorInput.data.modelID.trim()
+  const list = (errorInput.data.suggestions ?? []).map((v) => v.trim()).filter(Boolean)
+  const body = tr(translator, "error.chain.modelNotFound", `Model not found: ${p}/${m}`, { provider: p, model: m })
+  const tail = tr(translator, "error.chain.checkConfig", "Check your config (reigncode.json) provider/model names")
+  if (list.length) {
+    const suggestions = list.slice(0, 5).join(", ")
+    return [body, tr(translator, "error.chain.didYouMean", `Did you mean: ${suggestions}`, { suggestions }), tail].join(
+      "\n",
+    )
+  }
+  return [body, tail].join("\n")
+}

package/src/utils/server-health.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test"
+import type { ServerConnection } from "@/context/server"
+import { checkServerHealth } from "./server-health"
+
+const server: ServerConnection.HttpBase = {
+  url: "http://localhost:4096",
+}
+
+function abortFromInput(input: RequestInfo | URL, init?: RequestInit) {
+  if (init?.signal) return init.signal
+  if (input instanceof Request) return input.signal
+  return undefined
+}
+
+describe("checkServerHealth", () => {
+  test("returns healthy response with version", async () => {
+    const fetch = (async () =>
+      new Response(JSON.stringify({ healthy: true, version: "1.2.3" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      })) as unknown as typeof globalThis.fetch
+
+    const result = await checkServerHealth(server, fetch)
+
+    expect(result).toEqual({ healthy: true, version: "1.2.3" })
+  })
+
+  test("returns unhealthy when request fails", async () => {
+    const fetch = (async () => {
+      throw new Error("network")
+    }) as unknown as typeof globalThis.fetch
+
+    const result = await checkServerHealth(server, fetch)
+
+    expect(result).toEqual({ healthy: false })
+  })
+
+  test("uses timeout fallback when AbortSignal.timeout is unavailable", async () => {
+    const timeout = Object.getOwnPropertyDescriptor(AbortSignal, "timeout")
+    Object.defineProperty(AbortSignal, "timeout", {
+      configurable: true,
+      value: undefined,
+    })
+
+    let aborted = false
+    const fetch = ((input: RequestInfo | URL, init?: RequestInit) =>
+      new Promise<Response>((_resolve, reject) => {
+        const signal = abortFromInput(input, init)
+        signal?.addEventListener(
+          "abort",
+          () => {
+            aborted = true
+            reject(new DOMException("Aborted", "AbortError"))
+          },
+          { once: true },
+        )
+      })) as unknown as typeof globalThis.fetch
+
+    const result = await checkServerHealth(server, fetch, {
+      timeoutMs: 10,
+    }).finally(() => {
+      if (timeout) Object.defineProperty(AbortSignal, "timeout", timeout)
+      if (!timeout) Reflect.deleteProperty(AbortSignal, "timeout")
+    })
+
+    expect(aborted).toBe(true)
+    expect(result).toEqual({ healthy: false })
+  })
+
+  test("uses provided abort signal", async () => {
+    let signal: AbortSignal | undefined
+    const fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      signal = abortFromInput(input, init)
+      return new Response(JSON.stringify({ healthy: true, version: "1.2.3" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      })
+    }) as unknown as typeof globalThis.fetch
+
+    const abort = new AbortController()
+    await checkServerHealth(server, fetch, {
+      signal: abort.signal,
+    })
+
+    expect(signal).toBe(abort.signal)
+  })
+
+  test("retries transient failures and eventually succeeds", async () => {
+    let count = 0
+    const fetch = (async () => {
+      count += 1
+      if (count < 3) throw new TypeError("network")
+      return new Response(JSON.stringify({ healthy: true, version: "1.2.3" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      })
+    }) as unknown as typeof globalThis.fetch
+
+    const result = await checkServerHealth(server, fetch, {
+      retryCount: 2,
+      retryDelayMs: 1,
+    })
+
+    expect(count).toBe(3)
+    expect(result).toEqual({ healthy: true, version: "1.2.3" })
+  })
+
+  test("returns unhealthy when retries are exhausted", async () => {
+    let count = 0
+    const fetch = (async () => {
+      count += 1
+      throw new TypeError("network")
+    }) as unknown as typeof globalThis.fetch
+
+    const result = await checkServerHealth(server, fetch, {
+      retryCount: 2,
+      retryDelayMs: 1,
+    })
+
+    expect(count).toBe(3)
+    expect(result).toEqual({ healthy: false })
+  })
+})