dsh-skill-hub 0.3.12 → 0.3.13

package/src/reconcile.test.ts

@@ -0,0 +1,76 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { reconcileDisabledSkills } from './reconcile.ts'
+import { SkillHubStore, statePath } from './store.ts'
+
+describe('reconcileDisabledSkills', () => {
+  let dir: string
+  let home: string
+  let agentsHome: string
+  let previousAgentsHome: string | undefined
+  let store: SkillHubStore
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), 'dsh-skill-hub-reconcile-'))
+    home = join(dir, 'home')
+    agentsHome = join(dir, 'agents')
+    await mkdir(join(home, 'skills'), { recursive: true })
+    await mkdir(join(agentsHome, 'skills'), { recursive: true })
+    previousAgentsHome = process.env.DSH_AGENTS_HOME
+    process.env.DSH_AGENTS_HOME = agentsHome
+    store = new SkillHubStore(statePath(home))
+  })
+
+  afterEach(async () => {
+    if (previousAgentsHome === undefined) delete process.env.DSH_AGENTS_HOME
+    else process.env.DSH_AGENTS_HOME = previousAgentsHome
+    await rm(dir, { recursive: true, force: true })
+  })
+
+  it('rebuilds a missing record for a disabled directory bundle', async () => {
+    await mkdir(join(home, 'skills', 'paused-skill'))
+    await writeFile(
+      join(home, 'skills', 'paused-skill', 'SKILL.md.disabled'),
+      '---\nname: paused-skill\ndescription: Paused bundle\n---\n\nBody',
+      'utf8',
+    )
+    const added = await reconcileDisabledSkills(store, home)
+    expect(added).toHaveLength(1)
+    expect(await store.getDisabled('paused-skill')).toMatchObject({
+      name: 'paused-skill',
+      description: 'Paused bundle',
+      path: join(home, 'skills', 'paused-skill', 'SKILL.md.disabled'),
+      root: 'user-dsh',
+    })
+  })
+
+  it('rebuilds records for flat files in both user roots', async () => {
+    await writeFile(join(home, 'skills', 'flat-skill.md.disabled'), '---\nname: flat-skill\ndescription: Flat one\n---', 'utf8')
+    await writeFile(join(agentsHome, 'skills', 'agent-skill.md.disabled'), '---\nname: agent-skill\ndescription: Agent one\n---', 'utf8')
+    const added = await reconcileDisabledSkills(store, home)
+    expect(added.map((entry) => entry.name).sort()).toEqual(['agent-skill', 'flat-skill'])
+    expect((await store.getDisabled('agent-skill'))?.root).toBe('user-agents')
+    expect((await store.getDisabled('flat-skill'))?.root).toBe('user-dsh')
+  })
+
+  it('keeps existing records untouched and skips invalid disabled files', async () => {
+    const recordPath = join(home, 'skills', 'known-skill', 'SKILL.md.disabled')
+    await mkdir(join(home, 'skills', 'known-skill'))
+    await writeFile(recordPath, '---\nname: known-skill\ndescription: Fresh text\n---', 'utf8')
+    await store.addDisabled({ name: 'known-skill', description: 'Original', path: recordPath, root: 'user-dsh', disabledAt: 1 })
+    await writeFile(join(home, 'skills', 'broken.md.disabled'), '# no frontmatter', 'utf8')
+
+    expect(await reconcileDisabledSkills(store, home)).toEqual([])
+    expect((await store.getDisabled('known-skill'))?.description).toBe('Original')
+    expect(await store.getDisabled('broken')).toBeUndefined()
+  })
+
+  it('is idempotent across runs', async () => {
+    await writeFile(join(home, 'skills', 'flat-skill.md.disabled'), '---\nname: flat-skill\ndescription: Flat one\n---', 'utf8')
+    expect(await reconcileDisabledSkills(store, home)).toHaveLength(1)
+    expect(await reconcileDisabledSkills(store, home)).toEqual([])
+    expect(await store.listDisabled()).toHaveLength(1)
+  })
+})

package/src/reconcile.ts

@@ -0,0 +1,62 @@
+/**
+ * Sidecar reconcile for hub-disabled skills.
+ *
+ * The catalog merges two sources: enabled skills come from the provider
+ * (SKILL.md discovery), disabled skills come from the sidecar's `disabled`
+ * records. The two can drift — a sidecar restored from a backup, a hand
+ * edit, or an older build can leave a `SKILL.md.disabled` file on disk with
+ * no record, which makes the skill invisible in every view (it is neither
+ * enabled nor disabled) and leaves its origin collection rendering as an
+ * empty shell. This walk rebuilds the missing records from disk at startup.
+ */
+
+import { readFile, stat } from 'node:fs/promises'
+import type { DisabledSkill } from './protocol.ts'
+import { parseFrontmatter, rootPath, scanDisabledRoot, WRITABLE_ROOTS } from './skillfs.ts'
+import { dshHome } from './store.ts'
+
+/** Narrow store view used by the reconcile (SkillHubStore satisfies it). */
+export interface DisabledReconcileStore {
+  listDisabled(): Promise<DisabledSkill[]>
+  addDisabled(entry: DisabledSkill): Promise<void>
+}
+
+/**
+ * Add sidecar disabled records for every `.disabled` discovery file that has
+ * none yet. Existing records (matched by path or by name) win, so this never
+ * rewrites user data; unreadable or invalid files are skipped (they surface
+ * in the diagnostics scan instead). Returns the records added.
+ */
+export async function reconcileDisabledSkills(store: DisabledReconcileStore, home = dshHome()): Promise<DisabledSkill[]> {
+  const known = await store.listDisabled()
+  const knownNames = new Set(known.map((entry) => entry.name))
+  const knownPaths = new Set(known.map((entry) => entry.path))
+  const added: DisabledSkill[] = []
+  for (const root of WRITABLE_ROOTS) {
+    for (const path of await scanDisabledRoot(rootPath(root, home))) {
+      if (knownPaths.has(path)) continue
+      let text: string
+      try {
+        text = await readFile(path, 'utf8')
+      } catch {
+        continue
+      }
+      const parsed = parseFrontmatter(text)
+      if ('error' in parsed) continue
+      const { name, description } = parsed.value
+      if (knownNames.has(name)) continue
+      let disabledAt = 0
+      try {
+        disabledAt = (await stat(path)).mtimeMs
+      } catch {
+        continue // 扫描途中被删除
+      }
+      const record: DisabledSkill = { name, description, path, root, disabledAt }
+      await store.addDisabled(record)
+      knownNames.add(name)
+      knownPaths.add(path)
+      added.push(record)
+    }
+  }
+  return added
+}

package/src/skillfs/scan.ts

@@ -53,6 +53,44 @@ export function listSkillEntries(root: WritableRoot, home = dshHome()): Promise<
   return scanRoot(rootPath(root, home))
 }
 
+/**
+ * Scan one skills root for hub-disabled discovery files: directory bundles
+ * renamed to SKILL.md.disabled and flat <name>.md.disabled files. Used by
+ * the startup reconcile to rebuild sidecar records that were lost, which
+ * would otherwise leave the skill invisible in every view.
+ */
+export async function scanDisabledRoot(base: string): Promise<string[]> {
+  const paths: string[] = []
+  let names: string[]
+  try {
+    names = await readdir(base)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return paths
+    throw error
+  }
+  for (const name of names) {
+    if (name.startsWith('.')) continue
+    const absolute = join(base, name)
+    let stats
+    try {
+      stats = await stat(absolute)
+    } catch {
+      continue
+    }
+    if (stats.isDirectory()) {
+      const candidate = join(absolute, 'SKILL.md.disabled')
+      try {
+        if ((await stat(candidate)).isFile()) paths.push(candidate)
+      } catch {
+        // 目录里没有禁用的发现文件，跳过
+      }
+    } else if (name.endsWith('.md.disabled') && name !== 'SKILL.md.disabled') {
+      paths.push(absolute)
+    }
+  }
+  return paths.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+}
+
 /** UI metadata from `agents/openai.yaml` beside a directory skill (mirrors codex SkillInterface). */
 export interface SkillInterface {
   displayName?: string