reigncode-app 1.3.2

package/src/utils/id.ts

@@ -0,0 +1,99 @@
+import z from "zod"
+
+const prefixes = {
+  session: "ses",
+  message: "msg",
+  permission: "per",
+  user: "usr",
+  part: "prt",
+  pty: "pty",
+} as const
+
+const LENGTH = 26
+let lastTimestamp = 0
+let counter = 0
+
+type Prefix = keyof typeof prefixes
+export namespace Identifier {
+  export function schema(prefix: Prefix) {
+    return z.string().startsWith(prefixes[prefix])
+  }
+
+  export function ascending(prefix: Prefix, given?: string) {
+    return generateID(prefix, false, given)
+  }
+
+  export function descending(prefix: Prefix, given?: string) {
+    return generateID(prefix, true, given)
+  }
+}
+
+function generateID(prefix: Prefix, descending: boolean, given?: string): string {
+  if (!given) {
+    return create(prefix, descending)
+  }
+
+  if (!given.startsWith(prefixes[prefix])) {
+    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
+  }
+
+  return given
+}
+
+function create(prefix: Prefix, descending: boolean, timestamp?: number): string {
+  const currentTimestamp = timestamp ?? Date.now()
+
+  if (currentTimestamp !== lastTimestamp) {
+    lastTimestamp = currentTimestamp
+    counter = 0
+  }
+
+  counter += 1
+
+  let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
+
+  if (descending) {
+    now = ~now
+  }
+
+  const timeBytes = new Uint8Array(6)
+  for (let i = 0; i < 6; i += 1) {
+    timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
+  }
+
+  return prefixes[prefix] + "_" + bytesToHex(timeBytes) + randomBase62(LENGTH - 12)
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  let hex = ""
+  for (let i = 0; i < bytes.length; i += 1) {
+    hex += bytes[i].toString(16).padStart(2, "0")
+  }
+  return hex
+}
+
+function randomBase62(length: number): string {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+  const bytes = getRandomBytes(length)
+  let result = ""
+  for (let i = 0; i < length; i += 1) {
+    result += chars[bytes[i] % 62]
+  }
+  return result
+}
+
+function getRandomBytes(length: number): Uint8Array {
+  const bytes = new Uint8Array(length)
+  const cryptoObj = typeof globalThis !== "undefined" ? globalThis.crypto : undefined
+
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    cryptoObj.getRandomValues(bytes)
+    return bytes
+  }
+
+  for (let i = 0; i < length; i += 1) {
+    bytes[i] = Math.floor(Math.random() * 256)
+  }
+
+  return bytes
+}

package/src/utils/notification-click.test.ts

@@ -0,0 +1,27 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { handleNotificationClick, setNavigate } from "./notification-click"
+
+describe("notification click", () => {
+  afterEach(() => {
+    setNavigate(undefined as any)
+  })
+
+  test("navigates via registered navigate function", () => {
+    const calls: string[] = []
+    setNavigate((href) => calls.push(href))
+    handleNotificationClick("/abc/session/123")
+    expect(calls).toEqual(["/abc/session/123"])
+  })
+
+  test("does not navigate when href is missing", () => {
+    const calls: string[] = []
+    setNavigate((href) => calls.push(href))
+    handleNotificationClick(undefined)
+    expect(calls).toEqual([])
+  })
+
+  test("falls back to location.assign without registered navigate", () => {
+    handleNotificationClick("/abc/session/123")
+    // falls back to window.location.assign — no error thrown
+  })
+})

package/src/utils/notification-click.ts

@@ -0,0 +1,13 @@
+let nav: ((href: string) => void) | undefined
+
+export const setNavigate = (fn: (href: string) => void) => {
+  nav = fn
+}
+
+export const handleNotificationClick = (href?: string) => {
+  window.focus()
+  if (!href) return
+  if (nav) return nav(href)
+  console.warn("notification-click: navigate function not set, falling back to window.location.assign")
+  window.location.assign(href)
+}

package/src/utils/persist.test.ts

@@ -0,0 +1,115 @@
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test"
+
+type PersistTestingType = typeof import("./persist").PersistTesting
+
+class MemoryStorage implements Storage {
+  private values = new Map<string, string>()
+  readonly events: string[] = []
+  readonly calls = { get: 0, set: 0, remove: 0 }
+
+  clear() {
+    this.values.clear()
+  }
+
+  get length() {
+    return this.values.size
+  }
+
+  key(index: number) {
+    return Array.from(this.values.keys())[index] ?? null
+  }
+
+  getItem(key: string) {
+    this.calls.get += 1
+    this.events.push(`get:${key}`)
+    if (key.startsWith("opencode.throw")) throw new Error("storage get failed")
+    return this.values.get(key) ?? null
+  }
+
+  setItem(key: string, value: string) {
+    this.calls.set += 1
+    this.events.push(`set:${key}`)
+    if (key.startsWith("opencode.quota")) throw new DOMException("quota", "QuotaExceededError")
+    if (key.startsWith("opencode.throw")) throw new Error("storage set failed")
+    this.values.set(key, value)
+  }
+
+  removeItem(key: string) {
+    this.calls.remove += 1
+    this.events.push(`remove:${key}`)
+    if (key.startsWith("opencode.throw")) throw new Error("storage remove failed")
+    this.values.delete(key)
+  }
+}
+
+const storage = new MemoryStorage()
+
+let persistTesting: PersistTestingType
+
+beforeAll(async () => {
+  mock.module("@/context/platform", () => ({
+    usePlatform: () => ({ platform: "web" }),
+  }))
+
+  const mod = await import("./persist")
+  persistTesting = mod.PersistTesting
+})
+
+beforeEach(() => {
+  storage.clear()
+  storage.events.length = 0
+  storage.calls.get = 0
+  storage.calls.set = 0
+  storage.calls.remove = 0
+  Object.defineProperty(globalThis, "localStorage", {
+    value: storage,
+    configurable: true,
+  })
+})
+
+describe("persist localStorage resilience", () => {
+  test("does not cache values as persisted when quota write and eviction fail", () => {
+    const storageApi = persistTesting.localStorageWithPrefix("opencode.quota.scope")
+    storageApi.setItem("value", '{"value":1}')
+
+    expect(storage.getItem("opencode.quota.scope:value")).toBeNull()
+    expect(storageApi.getItem("value")).toBeNull()
+  })
+
+  test("disables only the failing scope when storage throws", () => {
+    const bad = persistTesting.localStorageWithPrefix("opencode.throw.scope")
+    bad.setItem("value", '{"value":1}')
+
+    const before = storage.calls.set
+    bad.setItem("value", '{"value":2}')
+    expect(storage.calls.set).toBe(before)
+    expect(bad.getItem("value")).toBeNull()
+
+    const healthy = persistTesting.localStorageWithPrefix("opencode.safe.scope")
+    healthy.setItem("value", '{"value":3}')
+    expect(storage.getItem("opencode.safe.scope:value")).toBe('{"value":3}')
+  })
+
+  test("failing fallback scope does not poison direct storage scope", () => {
+    const broken = persistTesting.localStorageWithPrefix("opencode.throw.scope2")
+    broken.setItem("value", '{"value":1}')
+
+    const direct = persistTesting.localStorageDirect()
+    direct.setItem("direct-value", '{"value":5}')
+
+    expect(storage.getItem("direct-value")).toBe('{"value":5}')
+  })
+
+  test("normalizer rejects malformed JSON payloads", () => {
+    const result = persistTesting.normalize({ value: "ok" }, '{"value":"\\x"}')
+    expect(result).toBeUndefined()
+  })
+
+  test("workspace storage sanitizes Windows filename characters", () => {
+    const result = persistTesting.workspaceStorage("C:\\Users\\foo")
+
+    expect(result).toStartWith("opencode.workspace.")
+    expect(result.endsWith(".dat")).toBeTrue()
+    expect(/[:\\/]/.test(result)).toBeFalse()
+  })
+})