opencode-extended-sidebar 0.2.90 → 0.2.91

package/src/pware.oc.core/pware.oc.core.runtimeConfig.ts

@@ -0,0 +1,41 @@
+/**
+ * pware.oc.core.runtimeConfig
+ *
+ * The plugin's kv-persisted runtime config as one DTO. Pure — parse and mutate
+ * here; the ui layer reads and writes it through the host `api.kv` (a JSON-safe
+ * value: plain objects/arrays/strings/numbers/booleans/null only, no Map/Set/
+ * Date/class instances).
+ */
+
+/** Runtime config persisted in the host kv store under `oes.config`. Extend as features land. */
+export type RuntimeConfigDto = {
+  /** Session ids pinned to the top of the My work queue, most recently pinned first. */
+  pinned_sessions: string[]
+}
+
+export function emptyRuntimeConfig(): RuntimeConfigDto {
+  return { pinned_sessions: [] }
+}
+
+/** Parse any kv value into a DTO, tolerating missing, malformed, or partial input. */
+export function parseRuntimeConfig(raw: unknown): RuntimeConfigDto {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return emptyRuntimeConfig()
+  const o = raw as Record<string, unknown>
+  const pinned = Array.isArray(o.pinned_sessions)
+    ? o.pinned_sessions.filter((id): id is string => typeof id === "string" && id.length > 0)
+    : []
+  return { pinned_sessions: pinned }
+}
+
+/** Pin a session — idempotent; a newly pinned session moves to the front. */
+export function pinSession(config: RuntimeConfigDto, sessionId: string): RuntimeConfigDto {
+  if (!sessionId) return config
+  const pinned = config.pinned_sessions.filter((id) => id !== sessionId)
+  return { ...config, pinned_sessions: [sessionId, ...pinned] }
+}
+
+/** Unpin a session — idempotent. */
+export function unpinSession(config: RuntimeConfigDto, sessionId: string): RuntimeConfigDto {
+  if (!sessionId) return config
+  return { ...config, pinned_sessions: config.pinned_sessions.filter((id) => id !== sessionId) }
+}

package/src/pware.oc.core/pware.oc.core.sqlite.ts

@@ -1,175 +1,164 @@
-/**
- * Thin readonly SQLite handle: prefers bun:sqlite, falls back to node:sqlite.
- * Never writes. Returns null when neither backend / DB is available.
- */
-import { createRequire } from "node:module"
-import fs from "node:fs"
-import { dbg, profile, pushScreenLine } from "./pware.oc.core.debug.js"
-
-export type SqlRow = Record<string, unknown>
-
-export type SqlDb = {
-  all: <T extends SqlRow = SqlRow>(sql: string, ...params: unknown[]) => T[]
-  get: <T extends SqlRow = SqlRow>(sql: string, ...params: unknown[]) => T | null
-  close: () => void
-}
-
-const require = createRequire(import.meta.url)
-
-/**
- * Lock wait before a query fails with SQLITE_BUSY. Fail-fast: a transient WAL
- * checkpoint lock should surface as an error row (and a `sql.busy` debug line)
- * instead of blocking the whole TUI for seconds.
- */
-const BUSY_TIMEOUT_MS = 100
-
-/** One-line query label for the profile log; computed lazily (profiling off = free). */
-function sqlLabel(sql: string): string {
-  return sql.replace(/\s+/g, " ").trim().slice(0, 80)
-}
-
-/** True when a thrown error is a SQLite lock/busy failure (SQLITE_BUSY). */
-export function isBusyError(e: unknown): boolean {
-  return e instanceof Error ? /locked|busy/i.test(e.message) : false
-}
-
-/**
- * Run a query, logging a `sql.busy` debug line when the DB is locked. The
- * error still propagates so `withDbRead` can retry once and then soft-fail.
- */
-function guardQuery<T>(sql: string, fn: () => T): T {
-  try {
-    return fn()
-  } catch (e) {
-    if (isBusyError(e)) dbg("sql.busy", "db locked", { q: sqlLabel(sql) })
-    throw e
-  }
-}
-
-function wrapBun(db: {
-  query: (sql: string) => { all: (...p: unknown[]) => SqlRow[]; get: (...p: unknown[]) => SqlRow | null }
-  exec: (sql: string) => void
-  close: () => void
-}): SqlDb {
-  try {
-    db.exec("PRAGMA query_only = ON")
-    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`)
-  } catch {
-    // older / restricted
-  }
-  return {
-    all: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
-      profile("sql", () => guardQuery(sql, () => db.query(sql).all(...params) as T[]), () => ({ q: sqlLabel(sql) })),
-    get: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
-      profile("sql", () => guardQuery(sql, () => (db.query(sql).get(...params) as T | null) ?? null), () => ({ q: sqlLabel(sql) })),
-    close: () => {
-      try {
-        db.close()
-      } catch {
-        // ignore
-      }
-    },
-  }
-}
-
-function wrapNodeSync(db: {
-  prepare: (sql: string) => {
-    all: (...p: unknown[]) => SqlRow[]
-    get: (...p: unknown[]) => SqlRow | undefined
-  }
-  exec: (sql: string) => void
-  close: () => void
-}): SqlDb {
-  try {
-    db.exec("PRAGMA query_only = ON")
-    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`)
-  } catch {
-    // ignore
-  }
-  return {
-    all: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
-      profile("sql", () => guardQuery(sql, () => db.prepare(sql).all(...params) as T[]), () => ({ q: sqlLabel(sql) })),
-    get: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
-      profile("sql", () => guardQuery(sql, () => (db.prepare(sql).get(...params) as T | undefined) ?? null), () => ({ q: sqlLabel(sql) })),
-    close: () => {
-      try {
-        db.close()
-      } catch {
-        // ignore
-      }
-    },
-  }
-}
-
-let hold: { path: string; db: SqlDb } | null = null
-
-function openFresh(dbPath: string): SqlDb | null {
-  if (!dbPath || !fs.existsSync(dbPath)) return null
-  try {
-    if (typeof process.versions.bun === "string") {
-      const { Database } = require("bun:sqlite") as {
-        Database: new (
-          path: string,
-          opts?: { readonly?: boolean; create?: boolean },
-        ) => Parameters<typeof wrapBun>[0]
-      }
-      return wrapBun(new Database(dbPath, { readonly: true, create: false }))
-    }
-  } catch {
-    // try node next
-  }
-  try {
-    const mod = require("node:sqlite") as {
-      DatabaseSync: new (
-        path: string,
-        opts?: { readOnly?: boolean },
-      ) => Parameters<typeof wrapNodeSync>[0]
-    }
-    if (!mod?.DatabaseSync) return null
-    return wrapNodeSync(new mod.DatabaseSync(dbPath, { readOnly: true }))
-  } catch {
-    return null
-  }
-}
-
-/** De-duplicated, non-empty string ids for `IN (...)` queries. */
-export function uniqueIds(ids: readonly string[]): string[] {
-  return [...new Set(ids.filter((id) => typeof id === "string" && id.length > 0))]
-}
-
-/** Drop the cached handle so the next open is a real reopen. */
-export function resetReadonlyDb(): void {
-  if (!hold) return
-  try {
-    hold.db.close()
-  } catch {
-    // ignore
-  }
-  hold = null
-}
-
-/** Retry a read after dropping a stale handle. */
-export function withDbRead<T>(run: () => T, fallback: (err: unknown) => T): T {
-  try {
-    return run()
-  } catch (e) {
-    resetReadonlyDb()
-    try {
-      return run()
-    } catch {
-      return fallback(e)
-    }
-  }
-}
-
-/** Open opencode.db readonly. Reuses one handle per path. Never throws — returns null on failure. */
-export function openReadonlyDb(dbPath: string): SqlDb | null {
-  if (!dbPath) return null
-  if (hold?.path === dbPath) return hold.db
-  resetReadonlyDb()
-  const db = openFresh(dbPath)
-  if (!db) return null
-  hold = { path: dbPath, db }
-  pushScreenLine("db open")
-  return db
-}
+/**
+ * Thin readonly SQLite handle: prefers bun:sqlite, falls back to node:sqlite.
+ * Never writes. Returns null when neither backend / DB is available.
+ */
+import { createRequire } from "node:module"
+import fs from "node:fs"
+import { dbg, profile, pushScreenLine } from "./pware.oc.core.debug.js"
+
+export type SqlRow = Record<string, unknown>
+
+export type SqlDb = {
+  readonly path?: string
+  all: <T extends SqlRow = SqlRow>(sql: string, ...params: unknown[]) => T[]
+  get: <T extends SqlRow = SqlRow>(sql: string, ...params: unknown[]) => T | null
+  close: () => void
+}
+
+const require = createRequire(import.meta.url)
+
+/**
+ * Lock wait before a query fails with SQLITE_BUSY. Fail-fast: a transient WAL
+ * checkpoint lock should surface as an error row (and a `sql.busy` debug line)
+ * instead of blocking the whole TUI for seconds.
+ */
+const BUSY_TIMEOUT_MS = 100
+
+/** One-line query label for the profile log; computed lazily (profiling off = free). */
+function sqlLabel(sql: string): string {
+  return sql.replace(/\s+/g, " ").trim().slice(0, 80)
+}
+
+/** True when a thrown error is a SQLite lock/busy failure (SQLITE_BUSY). */
+export function isBusyError(e: unknown): boolean {
+  return e instanceof Error ? /locked|busy/i.test(e.message) : false
+}
+
+/**
+ * Run a query, logging a `sql.busy` debug line when the DB is locked. The
+ * error still propagates so the readonly request gateway can retry the whole request.
+ */
+function guardQuery<T>(sql: string, fn: () => T): T {
+  try {
+    return fn()
+  } catch (e) {
+    if (isBusyError(e)) dbg("sql.busy", "db locked", { q: sqlLabel(sql) })
+    throw e
+  }
+}
+
+function wrapBun(dbPath: string, db: {
+  query: (sql: string) => { all: (...p: unknown[]) => SqlRow[]; get: (...p: unknown[]) => SqlRow | null }
+  exec: (sql: string) => void
+  close: () => void
+}): SqlDb {
+  try {
+    db.exec("PRAGMA query_only = ON")
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`)
+  } catch {
+    // older / restricted
+  }
+  return {
+    path: dbPath,
+    all: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => db.query(sql).all(...params) as T[]), () => ({ q: sqlLabel(sql) })),
+    get: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => (db.query(sql).get(...params) as T | null) ?? null), () => ({ q: sqlLabel(sql) })),
+    close: () => {
+      try {
+        db.close()
+      } catch {
+        // ignore
+      }
+    },
+  }
+}
+
+function wrapNodeSync(dbPath: string, db: {
+  prepare: (sql: string) => {
+    all: (...p: unknown[]) => SqlRow[]
+    get: (...p: unknown[]) => SqlRow | undefined
+  }
+  exec: (sql: string) => void
+  close: () => void
+}): SqlDb {
+  try {
+    db.exec("PRAGMA query_only = ON")
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`)
+  } catch {
+    // ignore
+  }
+  return {
+    path: dbPath,
+    all: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => db.prepare(sql).all(...params) as T[]), () => ({ q: sqlLabel(sql) })),
+    get: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => (db.prepare(sql).get(...params) as T | undefined) ?? null), () => ({ q: sqlLabel(sql) })),
+    close: () => {
+      try {
+        db.close()
+      } catch {
+        // ignore
+      }
+    },
+  }
+}
+
+let hold: { path: string; db: SqlDb } | null = null
+
+function openFresh(dbPath: string): SqlDb | null {
+  if (!dbPath || !fs.existsSync(dbPath)) return null
+  try {
+    if (typeof process.versions.bun === "string") {
+      const { Database } = require("bun:sqlite") as {
+        Database: new (
+          path: string,
+          opts?: { readonly?: boolean; create?: boolean },
+        ) => Parameters<typeof wrapBun>[1]
+      }
+      return wrapBun(dbPath, new Database(dbPath, { readonly: true, create: false }))
+    }
+  } catch {
+    // try node next
+  }
+  try {
+    const mod = require("node:sqlite") as {
+      DatabaseSync: new (
+        path: string,
+        opts?: { readOnly?: boolean },
+      ) => Parameters<typeof wrapNodeSync>[1]
+    }
+    if (!mod?.DatabaseSync) return null
+    return wrapNodeSync(dbPath, new mod.DatabaseSync(dbPath, { readOnly: true }))
+  } catch {
+    return null
+  }
+}
+
+/** De-duplicated, non-empty string ids for `IN (...)` queries. */
+export function uniqueIds(ids: readonly string[]): string[] {
+  return [...new Set(ids.filter((id) => typeof id === "string" && id.length > 0))]
+}
+
+/** Drop the cached handle so the next open is a real reopen. */
+export function resetReadonlyDb(): void {
+  if (!hold) return
+  try {
+    hold.db.close()
+  } catch {
+    // ignore
+  }
+  hold = null
+}
+
+/** Open opencode.db readonly. Reuses one handle per path. Never throws — returns null on failure. */
+export function openReadonlyDb(dbPath: string): SqlDb | null {
+  if (!dbPath) return null
+  if (hold?.path === dbPath) return hold.db
+  resetReadonlyDb()
+  const db = openFresh(dbPath)
+  if (!db) return null
+  hold = { path: dbPath, db }
+  pushScreenLine("db open")
+  return db
+}

package/src/pware.oc.core/pware.oc.core.sqliteGateway.ts

@@ -0,0 +1,89 @@
+/**
+ * One process-local policy for readonly SQLite requests. Requests are queued,
+ * retried as a whole, and publish only their final state. Stages yield to the
+ * event loop so the synchronous SQLite driver never forms one long main-thread
+ * burst when the worker fallback is active.
+ */
+import {
+  openReadonlyDb,
+  resetReadonlyDb,
+  type SqlDb,
+} from "./pware.oc.core.sqlite.js"
+
+export type ReadStage<T> = (db: SqlDb, state: T) => T
+
+export type ReadRequest<T> = {
+  readonly dbPath: string
+  readonly initial: () => T
+  readonly stages: readonly ReadStage<T>[]
+  readonly fallback: (error: unknown) => T
+}
+
+export type ReadGateway = {
+  run: <T>(request: ReadRequest<T>) => Promise<T>
+}
+
+type ReadGatewayDeps = {
+  readonly open: (dbPath: string) => SqlDb | null
+  readonly reset: () => void
+  readonly yieldControl: () => Promise<void>
+}
+
+export class ReadonlyDbUnavailableError extends Error {
+  readonly dbPath: string
+
+  constructor(dbPath: string) {
+    super(`readonly SQLite unavailable: ${dbPath}`)
+    this.name = "ReadonlyDbUnavailableError"
+    this.dbPath = dbPath
+  }
+}
+
+function yieldToEventLoop(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0))
+}
+
+export function createReadGateway(
+  deps: ReadGatewayDeps = {
+    open: openReadonlyDb,
+    reset: resetReadonlyDb,
+    yieldControl: yieldToEventLoop,
+  },
+): ReadGateway {
+  let tail = Promise.resolve()
+
+  const execute = async <T>(request: ReadRequest<T>): Promise<T> => {
+    let firstError: unknown = null
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const db = deps.open(request.dbPath)
+        if (!db) throw new ReadonlyDbUnavailableError(request.dbPath)
+        let state = request.initial()
+        for (let index = 0; index < request.stages.length; index += 1) {
+          const stage = request.stages[index]
+          if (!stage) continue
+          if (index > 0) await deps.yieldControl()
+          state = stage(db, state)
+        }
+        return state
+      } catch (error) {
+        firstError ??= error
+        deps.reset()
+      }
+    }
+    return request.fallback(firstError)
+  }
+
+  return {
+    run<T>(request: ReadRequest<T>): Promise<T> {
+      const result = tail.then(() => execute(request))
+      tail = result.then(
+        () => undefined,
+        () => undefined,
+      )
+      return result
+    },
+  }
+}
+
+export const readonlyReadGateway = createReadGateway()