ds-bot 0.0.0-stage → 0.1.1

package/src/host/home-lock.js

@@ -0,0 +1,91 @@
+// One writer per plugin home. dsh Web and dsh Desktop share ~/.dsh, and each host keeps
+// the team in memory and writes state.json whole, so two hosts at once would undo each
+// other's changes. The first host to load takes `state.lock`; a second one only reads.
+//
+// The lock is a small JSON file (pid, host, a random token) whose mtime the holder bumps
+// on a timer. It counts as gone when its process has exited (same host) or when it has
+// not been bumped for `staleMs`, which also covers a reused pid after a crash. On another
+// host only the age can tell, so a lock on shared storage waits out `staleMs`. The token,
+// not the pid, decides ownership: a holder that finds another token has lost the lock.
+import { randomUUID } from 'node:crypto'
+import { readFileSync, statSync, unlinkSync, utimesSync, writeFileSync } from 'node:fs'
+import { hostname } from 'node:os'
+
+export function pidAlive(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    // EPERM: the process exists but belongs to someone else.
+    return error?.code === 'EPERM'
+  }
+}
+
+export function homeLock(path, { staleMs = 60_000, beatMs = 15_000, host = hostname(), pid = process.pid, isAlive = pidAlive, now = Date.now } = {}) {
+  const token = randomUUID()
+  let timer
+
+  // undefined: no lock file; null: a file that does not parse (being written right now).
+  const read = () => {
+    try {
+      return JSON.parse(readFileSync(path, 'utf8'))
+    } catch (error) {
+      return error?.code === 'ENOENT' ? undefined : null
+    }
+  }
+  const age = () => {
+    try { return now() - statSync(path).mtimeMs } catch { return Infinity }
+  }
+  const live = (holder) => {
+    if (holder === undefined) return false
+    if (age() >= staleMs) return false
+    if (holder === null) return true
+    if (holder.host !== host) return true
+    // A lock this same process left (a plugin reload whose dispose never ran) is no rival.
+    return holder.pid !== pid && isAlive(holder.pid)
+  }
+  const owns = () => read()?.token === token
+
+  const beat = () => {
+    if (!owns()) {
+      stop()
+      return
+    }
+    const time = new Date(now())
+    try { utimesSync(path, time, time) } catch {}
+  }
+  const stop = () => {
+    if (timer !== undefined) clearInterval(timer)
+    timer = undefined
+  }
+
+  // Take the lock if it is free or its holder is gone. Returns undefined when this
+  // process holds it, else what the lock file says about the holder.
+  function claim() {
+    if (owns()) return undefined
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        writeFileSync(path, JSON.stringify({ pid, host, token, since: now() }), { flag: 'wx' })
+        stop()
+        timer = setInterval(beat, beatMs)
+        timer.unref?.()
+        return undefined
+      } catch (error) {
+        if (error?.code !== 'EEXIST') throw error
+      }
+      const holder = read()
+      if (live(holder)) return holder ?? {}
+      try { unlinkSync(path) } catch {}
+    }
+    return read() ?? {}
+  }
+
+  function release() {
+    stop()
+    if (owns()) {
+      try { unlinkSync(path) } catch {}
+    }
+  }
+
+  return { claim, owns, release, read }
+}

package/src/host/images.js

@@ -0,0 +1,174 @@
+// Images for text-only models. Every model may take images; before a Session request
+// reaches a model that cannot read them, each image becomes text from a vision model.
+// Texts are kept per attachment, so later requests repeat the same words and the
+// prompt cache still hits.
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { BlockAssembler } from '@deepseek-ai/dsh-llm'
+import { OCR_CACHE_MAX, OCR_PROMPT, OCR_RETRY_MS, OCR_TIMEOUT_MS } from './constants.js'
+import { splitRef } from './text.js'
+
+export function install(rt) {
+  const { ctx, config, home } = rt
+
+  // `textOnlyModels` names models whose provider claims image input but rejects it.
+  const textOnlyModels = new Set(config.textOnlyModels ?? [])
+  const ocrPath = join(home, 'ocr.json')
+  let ocrCache = null
+  let ocrWriting = Promise.resolve()
+  const ocrPending = new Map()
+  const ocrFailed = new Map()
+
+  const liveImages = message => Array.isArray(message?.content)
+    && message.content.some(block => block?.type === 'image' && !block.offloaded)
+
+  async function readsImages(provider, model) {
+    if (textOnlyModels.has(`${provider}/${model}`)) return false
+    try {
+      const info = await ctx.llm.resolveModelInfo(provider, model)
+      return info.inputModalities === undefined || info.inputModalities.includes('image')
+    } catch {
+      return true
+    }
+  }
+
+  // The configured `ocrModel` first, then served models that declare image input, the
+  // DSH default among them first.
+  async function ocrRoute() {
+    const models = await rt.catalog()
+    const served = new Set(models.map(entry => entry.ref))
+    const declared = models.filter(entry => entry.input?.includes('image')).map(entry => entry.ref)
+    const fallback = rt.defaultRef()
+    for (const ref of new Set([config.ocrModel, ...declared.filter(ref => ref === fallback), ...declared])) {
+      const route = splitRef(ref)
+      if (route && served.has(ref) && await readsImages(route.provider, route.model)) return { ref, ...route }
+    }
+    return undefined
+  }
+
+  async function loadOcr() {
+    if (ocrCache !== null) return
+    try {
+      ocrCache = new Map(Object.entries(JSON.parse(await readFile(ocrPath, 'utf8'))))
+    } catch (error) {
+      if (error?.code !== 'ENOENT') rt.warn('ds-bot: unreadable OCR cache %s: %s', ocrPath, error)
+      ocrCache = new Map()
+    }
+  }
+
+  function saveOcr() {
+    while (ocrCache.size > OCR_CACHE_MAX) ocrCache.delete(ocrCache.keys().next().value)
+    const snapshot = JSON.stringify(Object.fromEntries(ocrCache))
+    ocrWriting = ocrWriting.then(async () => {
+      await mkdir(home, { recursive: true })
+      const temp = `${ocrPath}.${process.pid}.tmp`
+      await writeFile(temp, snapshot, 'utf8')
+      await rename(temp, ocrPath)
+    }).catch(error => rt.warn('ds-bot: OCR cache write failed: %s', error))
+  }
+
+  // `sessionId` is the Session the reading is for; its usage counts there.
+  async function readImage(attachment, sessionId) {
+    const route = await ocrRoute()
+    if (route === undefined) throw new Error('no vision model is available')
+    const assembler = new BlockAssembler()
+    // No sessionId: this call is not a Session request, so the hook below lets it through.
+    for await (const chunk of ctx.llm.stream({
+      provider: route.provider,
+      model: route.model,
+      messages: rt.tagUsage([{ role: 'user', content: [{ type: 'image', attachment }, { type: 'text', text: OCR_PROMPT }] }], { sessionId, kind: 'image' }),
+      maxTokens: 8192,
+      signal: AbortSignal.timeout(OCR_TIMEOUT_MS),
+    })) assembler.push(chunk)
+    const finish = assembler.finish
+    if (finish.kind === 'error' || finish.kind === 'aborted') throw new Error(finish.failure?.message ?? finish.kind)
+    const text = assembler.blocks().filter(block => block.type === 'text').map(block => block.text).join('\n').trim()
+    if (text === '') throw new Error('the vision model returned no text')
+    const model = (await rt.catalog()).find(entry => entry.ref === route.ref)?.name ?? route.model
+    return { text, model }
+  }
+
+  // Resolves to the cached reading, or to null when the image cannot be read now.
+  async function imageReading(attachment, sessionId) {
+    const id = String(attachment.attachmentId)
+    if (ocrCache.has(id)) return ocrCache.get(id)
+    const failed = ocrFailed.get(id)
+    if (failed && Date.now() - failed.at < OCR_RETRY_MS) return null
+    if (!ocrPending.has(id)) {
+      ocrPending.set(id, readImage(attachment, sessionId).then((reading) => {
+        ocrCache.set(id, reading)
+        ocrFailed.delete(id)
+        saveOcr()
+        return reading
+      }, (error) => {
+        rt.warn('ds-bot: could not read image %s: %s', id, error)
+        ocrFailed.set(id, { at: Date.now() })
+        return null
+      }).finally(() => ocrPending.delete(id)))
+    }
+    return ocrPending.get(id)
+  }
+
+  const imageLabel = attachment => (attachment.name
+    ? `"${attachment.name}"`
+    : `sha256:${String(attachment.attachmentId).slice('sha256:'.length, 'sha256:'.length + 8)}`)
+
+  function imageAsText(attachment, reading) {
+    const label = imageLabel(attachment)
+    return {
+      type: 'text',
+      text: reading === null
+        ? `[Image ${label}: you cannot see images and it could not be read right now. Ask the user what it shows if it matters.]`
+        : `[Image ${label}. You cannot see images, so ${reading.model} read it for you:]\n${reading.text}\n[End of image ${label}]`,
+    }
+  }
+
+  // Members read the group as text, so a picture posted there reaches every member,
+  // vision model or not, as its reading.
+  async function imagesForGroup(attachments, sessionId) {
+    await loadOcr()
+    return Promise.all(attachments.map(async (attachment) => {
+      const reading = await imageReading(attachment, sessionId)
+      const label = imageLabel(attachment)
+      return reading === null
+        ? `[Image ${label}: it could not be read right now. Ask the user what it shows if it matters.]`
+        : `[Image ${label}, read by ${reading.model}:]\n${reading.text}\n[End of image ${label}]`
+    }))
+  }
+
+  async function withImagesAsText(messages, sessionId) {
+    await loadOcr()
+    const images = new Map()
+    for (const message of messages) {
+      if (!liveImages(message)) continue
+      for (const block of message.content) {
+        if (block?.type === 'image' && !block.offloaded) images.set(String(block.attachment.attachmentId), block.attachment)
+      }
+    }
+    const readings = new Map(await Promise.all([...images].map(async ([id, attachment]) => [id, await imageReading(attachment, sessionId)])))
+    return messages.map(message => (liveImages(message)
+      ? {
+          ...message,
+          content: message.content.map(block => (block?.type === 'image' && !block.offloaded
+            ? imageAsText(block.attachment, readings.get(String(block.attachment.attachmentId)))
+            : block)),
+        }
+      : message))
+  }
+
+  ctx.on('llm/stream', (options, next) => {
+    if (options.sessionId === undefined || !(options.messages ?? []).some(liveImages)) return next()
+    return (async function* imagesAsTextOrPass() {
+      await rt.load()
+      if (rt.roomOf(options.sessionId) !== undefined || await readsImages(options.provider, options.model)) {
+        yield* next()
+        return
+      }
+      // `next` cannot take new messages, so the rewritten request starts over; it
+      // carries no image, so this listener lets it through.
+      yield* ctx.llm.stream({ ...options, messages: await withImagesAsText(options.messages, options.sessionId) })
+    })()
+  })
+
+  Object.assign(rt, { imagesForGroup })
+}