dsh-skill-picker 0.5.20 → 0.5.22

package/src/client/shared-state.js

@@ -0,0 +1,189 @@
+/**
+ * Shared picker state — the pinned list and the usage history, kept in ONE place
+ * instead of per browser origin.
+ *
+ * `localStorage` is scoped to an origin, so the desktop app (`dsh-app://app`),
+ * the web UI (`http://127.0.0.1:3080`) and a phone each kept a private copy: pin
+ * a skill on the desktop and the web UI never saw it. The host stores the list
+ * once per DSH home (`$DSH_HOME/dsh-skill-picker-state.json`) and this module
+ * mirrors it into `localStorage`.
+ *
+ * Why mirror instead of replacing `localStorage`: the ranking runs during render
+ * and reads its inputs SYNCHRONOUSLY, so the data path has to stay synchronous.
+ * The mirror keeps that true — the host copy is the source of truth, and
+ * `localStorage` is the synchronous cache of it. Every local write is pushed
+ * back, so both ends converge.
+ *
+ * Every function here is best-effort: a missing route or an offline host must
+ * leave the picker working exactly as it did before, on local data alone.
+ */
+
+/** Same keys the panel reads synchronously. */
+export const PINNED_KEY = 'dsh-skill-picker:pinned'
+export const USAGE_KEY = 'dsh-skill-picker:usage'
+
+/**
+ * Set once this browser has completed a sync against the shared file.
+ *
+ * The first sync of a browser that already had pins MUST union instead of
+ * adopting: whichever client happens to boot first would otherwise overwrite
+ * the file, and the next client would adopt that and silently lose its own
+ * pins. After the first sync this browser follows the file, so a pin removed
+ * on one client really disappears from the others.
+ */
+const SYNCED_KEY = 'dsh-skill-picker:shared-synced'
+
+/** Host route (same origin as the GUI in both the desktop app and the web UI). */
+const ENDPOINT = '/dsh-skill-picker/state'
+
+/** Fired after a pull changes the mirror, so open surfaces re-read it. */
+export const SHARED_STATE_EVENT = 'dsh-skill-picker:shared-state'
+
+/** Read the mirrored pinned list; never throws. */
+function readLocalPinned() {
+  try {
+    const parsed = JSON.parse(localStorage.getItem(PINNED_KEY) ?? '[]')
+    return Array.isArray(parsed) ? parsed.filter((name) => typeof name === 'string') : []
+  } catch {
+    return []
+  }
+}
+
+/** Read the mirrored usage history; never throws. */
+function readLocalUsage() {
+  try {
+    const parsed = JSON.parse(localStorage.getItem(USAGE_KEY) ?? '{}')
+    return parsed !== null && typeof parsed === 'object' ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+/** Write the mirror; never throws. */
+function writeLocal(state) {
+  try {
+    localStorage.setItem(PINNED_KEY, JSON.stringify(state?.pinned ?? []))
+    localStorage.setItem(USAGE_KEY, JSON.stringify(state?.usage ?? {}))
+  } catch {
+    /* storage unavailable — the host copy is still authoritative */
+  }
+}
+
+/** Whether a state object carries anything worth adopting. */
+function isEmptyState(state) {
+  if (state === null || state === undefined || typeof state !== 'object') return true
+  const pinned = Array.isArray(state.pinned) ? state.pinned : []
+  const usage = state.usage !== null && typeof state.usage === 'object' ? state.usage : {}
+  return pinned.length === 0 && Object.keys(usage).length === 0
+}
+
+/** Whether this browser has ever completed a sync. */
+function hasSynced() {
+  try {
+    return localStorage.getItem(SYNCED_KEY) === '1'
+  } catch {
+    return false
+  }
+}
+
+/** Remember that this browser is now following the shared file. */
+function markSynced() {
+  try {
+    localStorage.setItem(SYNCED_KEY, '1')
+  } catch {
+    /* private mode: it simply unions again next time, which is the safe side */
+  }
+}
+
+/** Push the local mirror to the shared file.
+ *
+ * @param options.migrate - first-run mode: the host unions the incoming state
+ *   with whatever is already stored (instead of overwriting it) and returns the
+ *   result, which is then adopted locally. Use it only when the shared file is
+ *   known to be absent.
+ * @returns whether the host accepted the write.
+ */
+export async function pushSharedState({ migrate = false } = {}) {
+  try {
+    const response = await fetch(`${ENDPOINT}${migrate ? '?migrate=1' : ''}`, {
+      method: 'PUT',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ pinned: readLocalPinned(), usage: readLocalUsage() }),
+    })
+    if (!response.ok) return false
+    const body = await response.json()
+    if (body?.ok !== true) return false
+    if (migrate) writeLocal(body.state)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Pull the shared file into the local mirror.
+ *
+ * When this browser has never synced before and already holds pins/usage, the
+ * pull goes through the UNIONING migration instead of a plain adopt — otherwise
+ * whichever client boots first overwrites the file and the next one silently
+ * loses its own pins. Once a browser has synced, it follows the file, so a pin
+ * removed on another client really disappears here too.
+ *
+ * @returns whether the mirror was refreshed from the host.
+ */
+export async function pullSharedState() {
+  try {
+    const response = await fetch(ENDPOINT, { headers: { accept: 'application/json' } })
+    if (!response.ok) return false
+    const body = await response.json()
+    if (body?.ok !== true) return false
+
+    const localHasData = !isEmptyState({ pinned: readLocalPinned(), usage: readLocalUsage() })
+
+    // Nothing shared yet: this browser seeds it.
+    if (body.state === null || body.state === undefined) {
+      const pushed = await pushSharedState({ migrate: true })
+      if (pushed) markSynced()
+      return true
+    }
+
+    // First sync on a browser that has its own data: union, never overwrite.
+    if (!hasSynced() && localHasData) {
+      const pushed = await pushSharedState({ migrate: true })
+      if (pushed) {
+        markSynced()
+        return true
+      }
+    }
+
+    // The shared file exists but is empty, and this browser is the only one
+    // still holding data: push it rather than blanking the mirror.
+    if (isEmptyState(body.state) && localHasData) {
+      const pushed = await pushSharedState({ migrate: true })
+      if (pushed) markSynced()
+      return true
+    }
+
+    writeLocal(body.state)
+    markSynced()
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Pull, then tell open surfaces to re-read the mirror.
+ * @returns whether anything was pulled.
+ */
+export async function syncSharedState() {
+  const pulled = await pullSharedState()
+  if (pulled) {
+    try {
+      window.dispatchEvent(new Event(SHARED_STATE_EVENT))
+    } catch {
+      /* an environment without window cannot have listeners either */
+    }
+  }
+  return pulled
+}

package/src/index.js

@@ -18,12 +18,12 @@
  * @module dsh-skill-picker
  */
 
-import { readFile, readdir } from 'node:fs/promises'
+import { mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
 import { isDirectoryEntry } from './dir-entry.js'
-import { healUiSkillPatches } from './patch-ui-skill.js'
+import { dshHome, healUiSkillPatches, revertUiSkillPatches } from './patch-ui-skill.js'
 
 /** Required services: the route registry and the prompt band. */
 export const inject = ['webServer', 'systemPrompt']
@@ -253,6 +253,117 @@ export function reportUiSkillPatches(report, io = console) {
   }
 }
 
+/**
+ * Shared picker state: the pinned list and the usage history, stored ONCE per
+ * DSH home instead of per browser origin.
+ *
+ * Why it exists: `localStorage` is scoped to an origin, so the desktop app
+ * (`dsh-app://app`), the web UI (`http://127.0.0.1:3080`) and a phone all kept
+ * their own copy — pin a skill on the desktop and the web UI never sees it.
+ * Both halves now read and write this one file.
+ *
+ * @returns the absolute path of the shared state file.
+ */
+function sharedStateFile() {
+  return path.join(dshHome(), 'dsh-skill-picker-state.json')
+}
+
+/** Coerce anything into `{ pinned: string[], usage: {name: {count, lastUsed}} }`. */
+function normalizeSharedState(value) {
+  const source = value !== null && typeof value === 'object' ? value : {}
+  const pinned = Array.isArray(source.pinned)
+    ? [...new Set(source.pinned.filter((name) => typeof name === 'string' && name !== ''))]
+    : []
+  const usage = {}
+  const rawUsage = source.usage !== null && typeof source.usage === 'object' ? source.usage : {}
+  for (const [name, entry] of Object.entries(rawUsage)) {
+    if (typeof name !== 'string' || name === '') continue
+    const record = entry !== null && typeof entry === 'object' ? entry : {}
+    const count = Number.isFinite(record.count) ? Math.max(0, Math.trunc(record.count)) : 0
+    const lastUsed = Number.isFinite(record.lastUsed) ? Math.max(0, Math.trunc(record.lastUsed)) : 0
+    if (count === 0 && lastUsed === 0) continue
+    usage[name] = { count, lastUsed }
+  }
+  return { pinned, usage }
+}
+
+/** Read the shared state, or null when the file does not exist yet. */
+async function readSharedState() {
+  try {
+    return normalizeSharedState(JSON.parse(await readFile(sharedStateFile(), 'utf8')))
+  } catch {
+    return null
+  }
+}
+
+/** Write the shared state atomically (temp + rename), creating the home if needed. */
+async function writeSharedState(state) {
+  const normal = normalizeSharedState(state)
+  const file = sharedStateFile()
+  await mkdir(path.dirname(file), { recursive: true })
+  const tmp = `${file}.tmp`
+  await writeFile(tmp, `${JSON.stringify(normal, null, 2)}\n`, 'utf8')
+  await rename(tmp, file)
+  return normal
+}
+
+/**
+ * First-run migration: union both ends instead of letting whichever browser
+ * happened to write first win, so nobody silently loses their pins.
+ */
+function mergeSharedState(a, b) {
+  const left = normalizeSharedState(a)
+  const right = normalizeSharedState(b)
+  const pinned = [...left.pinned]
+  for (const name of right.pinned) if (!pinned.includes(name)) pinned.push(name)
+  const usage = { ...left.usage }
+  for (const [name, entry] of Object.entries(right.usage)) {
+    const previous = usage[name]
+    usage[name] = previous === undefined
+      ? entry
+      : { count: Math.max(previous.count, entry.count), lastUsed: Math.max(previous.lastUsed, entry.lastUsed) }
+  }
+  return normalizeSharedState({ pinned, usage })
+}
+
+/** Read a JSON request body with a hard cap, so a bad client cannot grow memory. */
+async function readJsonBody(req) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    size += chunk.length
+    if (size > 1_000_000) throw new Error('shared state body too large')
+    chunks.push(chunk)
+  }
+  if (chunks.length === 0) return {}
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}
+
+/**
+ * `GET /dsh-skill-picker/state` → `{ ok, state }` (`state: null` before the
+ * first write). `PUT` with `{ pinned, usage }` → the stored state; `?migrate=1`
+ * unions the incoming state with the stored one and returns the result.
+ */
+async function handleSharedState(req, res, url) {
+  const json = (code, payload) => {
+    res.writeHead(code, { 'content-type': 'application/json; charset=utf-8' })
+    res.end(JSON.stringify(payload))
+  }
+  try {
+    if (req.method === 'PUT' || req.method === 'POST') {
+      const incoming = normalizeSharedState(await readJsonBody(req))
+      const migrate = url.searchParams.get('migrate') === '1'
+      const stored = migrate ? await readSharedState() : null
+      const next = stored === null ? await writeSharedState(incoming) : await writeSharedState(mergeSharedState(stored, incoming))
+      json(200, { ok: true, state: next })
+      return
+    }
+    json(200, { ok: true, state: await readSharedState() })
+  } catch (error) {
+    json(500, { ok: false, error: String(error?.message ?? error) })
+  }
+}
+
 /**
  * Mount the skills route and the prompt section.
  * @param ctx - context carrying webServer and systemPrompt.
@@ -261,8 +372,13 @@ export function apply(ctx) {
   ctx.effect(() => {
     const handler = async (req, res) => {
       try {
+        const url = new URL(req.url ?? '/', 'http://dsh')
+        if (url.pathname === '/dsh-skill-picker/state') {
+          await handleSharedState(req, res, url)
+          return
+        }
         // cwd query carries the active session's workspace root from the client.
-        const cwd = req.url !== undefined ? new URL(req.url, 'http://dsh').searchParams.get('cwd') ?? undefined : undefined
+        const cwd = url.searchParams.get('cwd') ?? undefined
         const skills = await scanSkills(cwd)
         res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' })
         res.end(JSON.stringify({ ok: true, complete: true, skills }))
@@ -280,17 +396,32 @@ export function apply(ctx) {
     text: SKILL_PICKER_GUIDANCE,
   }), 'dsh-skill-picker: prompt section')
 
-  // Self-healing patch for the official ui-skill package: keeps the `/`
-  // completion's skill group ordered above commands and its matching fuzzy
-  // across DSH upgrades. Runs once per boot; idempotent, backed up, and
-  // never allowed to take the host down.
+  // The `/` enhancement no longer edits official files.
+  //
+  // Since v0.5.15 it takes over the LIVE trigger source at runtime, which does
+  // everything the old file patch did (skill group first, fuzzy+pinyin matching,
+  // usage tracking) without touching a single file. The patch is therefore
+  // redundant — and a modified copy of an official package is confusing in its
+  // own right: it made the desktop and web profiles disagree about one shared
+  // file, and it is what made "is this the original?" impossible to answer.
   //
-  // Logging is gated on "did this boot change anything / fail" rather than
-  // "was a target found" — see `reportUiSkillPatches` (issue #8).
+  // So the default is now to RESTORE our own patch (from the `.bak` it made).
+  // Set DSH_SKILL_PICKER_FILE_PATCH=1 to fall back to the old behaviour on a
+  // kernel whose trigger registry has no live sources to take over.
   ctx.effect(() => {
-    healUiSkillPatches().then((report) => {
-      reportUiSkillPatches(report)
-    }).catch((error) => {
+    const enabled = process.env.DSH_SKILL_PICKER_FILE_PATCH === '1'
+    const task = enabled
+      ? healUiSkillPatches().then((report) => reportUiSkillPatches(report))
+      : revertUiSkillPatches().then((report) => {
+        if (report.restored.length > 0) {
+          console.log('[dsh-skill-picker] ui-skill patch retired; restored original file(s):',
+            report.restored.join(', '))
+        }
+        if (report.errors.length > 0) {
+          console.warn('[dsh-skill-picker] ui-skill restore errors:', JSON.stringify(report.errors))
+        }
+      })
+    task.catch((error) => {
       console.warn('[dsh-skill-picker] ui-skill patch failed:', error)
     })
     return () => {}

package/src/patch-ui-skill.js

@@ -326,6 +326,53 @@ export async function patchUiSkillFile(file) {
  * into `errors` so the host boot is never taken down by a broken patch.
  * @returns {Promise<{files: Array, errors: string[]}>}
  */
+/**
+ * Undo our own file patch: restore every `<file>.dsh-skill-picker.bak` we made.
+ *
+ * The `/` enhancement has not needed this patch since v0.5.15, which takes over
+ * the LIVE trigger source at runtime instead. Keeping the patch meant shipping a
+ * modified copy of an official package — confusing on its own, and it made the
+ * desktop and web profiles disagree about the same file.
+ *
+ * Restores only a file that still carries OUR marker, so a file edited by
+ * something else since is left alone. Idempotent: after one pass there is
+ * nothing left to restore.
+ *
+ * @returns {Promise<{restored: string[], errors: string[]}>}
+ */
+export async function revertUiSkillPatches() {
+  const files = await uiSkillClientPaths()
+  const restored = []
+  const errors = []
+  for (const file of files) {
+    const backup = `${file}.dsh-skill-picker.bak`
+    try {
+      let text
+      try {
+        text = await readFile(file, 'utf8')
+      } catch {
+        continue
+      }
+      if (!PATCHES.some((patch) => patch.isApplied(text))) continue
+      let original
+      try {
+        original = await readFile(backup, 'utf8')
+      } catch {
+        continue
+      }
+      // Same temp+rename dance as the patch itself: never write a hardlinked
+      // package file in place (that would mutate the shared pnpm store).
+      const tmp = `${file}.dsh-skill-picker.tmp`
+      await writeFile(tmp, original, 'utf8')
+      await rename(tmp, file)
+      restored.push(file)
+    } catch (error) {
+      errors.push(`${file}: ${String(error?.message ?? error)}`)
+    }
+  }
+  return { restored, errors }
+}
+
 export async function healUiSkillPatches() {
   const files = await uiSkillClientPaths()
   const filesReport = []