dsh-skill-hub 0.3.19 → 0.3.21

package/src/skillfs.ts

@@ -83,14 +83,18 @@ export async function enableSkill(disabledPath: string): Promise<string> {
 }
 
 /**
- * Move a skill (directory bundle or flat .md file) into the root's trash.
- * The skill stays recoverable: the source is renamed into
- * <root>/.trash/<name>-<timestamp>. A directory bundle is addressed by its
- * SKILL.md path and moved as a whole directory.
+ * Move one already-resolved skill (a bundle directory or a flat .md file) into
+ * its root's trash as `<root>/.trash/<name>-<timestamp>`.
+ *
+ * The layout is the restore contract, not an implementation detail:
+ * `restoreSkill` renames the entry back and only proves the parent is `.trash`,
+ * and `clearTrash` deletes in place. Every producer of a trash entry must go
+ * through here — skill delete, the hub-disabled whole-group delete, and repo
+ * import's placeholder replacement all move skills for the same recovery flow.
+ *
  * @returns the trashed path plus the original path that was moved.
  */
-export async function trashSkill(sourcePath: string): Promise<{ path: string; source: string }> {
-  const source = basename(sourcePath) === 'SKILL.md' ? dirname(sourcePath) : sourcePath
+export async function moveIntoTrash(source: string): Promise<{ path: string; source: string }> {
   const trashDir = join(dirname(source), '.trash')
   await mkdir(trashDir, { recursive: true })
   const target = join(trashDir, basename(source) + '-' + Date.now())
@@ -98,6 +102,29 @@ export async function trashSkill(sourcePath: string): Promise<{ path: string; so
   return { path: target, source }
 }
 
+/**
+ * The filesystem entry behind a discovery file: a directory bundle is addressed
+ * by its `SKILL.md` (or `SKILL.md.disabled`) and moved as a whole directory, a
+ * flat `<name>.md` file is moved as itself. Single definition of that mapping —
+ * delete, restore, sync-replace and placeholder retirement must all agree on it,
+ * or one of them moves a bundle's discovery file and leaves an empty directory.
+ */
+export function trashSourceOf(discoveryPath: string): string {
+  const base = basename(discoveryPath)
+  return base === 'SKILL.md' || base === 'SKILL.md.disabled' ? dirname(discoveryPath) : discoveryPath
+}
+
+/**
+ * Move a skill (directory bundle or flat .md file) into the root's trash.
+ * The skill stays recoverable: the source is renamed into
+ * <root>/.trash/<name>-<timestamp>. A directory bundle is addressed by its
+ * SKILL.md (or SKILL.md.disabled) path and moved as a whole directory.
+ * @returns the trashed path plus the original path that was moved.
+ */
+export async function trashSkill(sourcePath: string): Promise<{ path: string; source: string }> {
+  return moveIntoTrash(trashSourceOf(sourcePath))
+}
+
 /** Restore a trashed skill (directory or flat file) to its original location. */
 export async function restoreSkill(entry: TrashEntry, home = dshHome()): Promise<string> {
   if (basename(dirname(entry.path)) !== '.trash') {
@@ -127,7 +154,15 @@ function skillFileKind(path: string): 'directory' | 'flat' | undefined {
   return undefined
 }
 
-/** Repair one file on disk when its frontmatter is auto-fixable. Returns the new text. */
+/**
+ * Repair one file on disk when its frontmatter is auto-fixable. Returns the new text.
+ *
+ * The write is atomic (sibling temp file + rename), matching the sidecar's
+ * persist path: this rewrites a real skill file in place, and a crash midway
+ * through a plain write would leave a truncated SKILL.md — exactly the failure
+ * the store layer already guards against. The `.tmp` sibling is never picked
+ * up by discovery (only `SKILL.md` and `*.md` are scanned).
+ */
 export async function fixDiagnosticFile(path: string, home = dshHome()): Promise<string> {
   const root = rootOfPath(path, home)
   if (root === undefined) throw new TypeError('not a hub writable skill path: ' + path)
@@ -137,6 +172,14 @@ export async function fixDiagnosticFile(path: string, home = dshHome()): Promise
   // Validate the repaired text parses as a legal skill (prevents writing a still-broken file).
   const parsed = parseFrontmatter(repairedText)
   if ('error' in parsed) throw new TypeError('repaired frontmatter still invalid: ' + parsed.error)
-  await writeFile(path, repairedText, 'utf8')
+  const tmp = path + '.tmp'
+  await writeFile(tmp, repairedText, 'utf8')
+  try {
+    await rename(tmp, path)
+  } catch (error) {
+    // Never leave a stray temp file behind when the rename is what failed.
+    await rm(tmp, { force: true }).catch(() => {})
+    throw error
+  }
   return path
 }

package/src/store/migrate.ts

@@ -90,7 +90,7 @@ export interface HydratedState {
   tagsById: Map<string, SkillTag>
   sourcesByRepo: Map<string, SourceRecord>
   marketSources: MarketSourceRecord[]
-  trashByName: Map<string, TrashEntry>
+  trashByPath: Map<string, TrashEntry>
   skillStats: SkillStatsCheckpoint | undefined
   marketStats: MarketStatsSnapshot | undefined
   collectionOrder: string[]
@@ -179,14 +179,16 @@ export function hydrateMigratedState(migrated: MigratedStore): HydratedState {
     }
   }
 
-  const trashByName = new Map<string, TrashEntry>()
+  const trashByPath = new Map<string, TrashEntry>()
   if (Array.isArray(migrated.trash)) {
     for (const entry of migrated.trash as unknown[]) {
       const item = entry as { name?: unknown; path?: unknown; movedAt?: unknown; sourcePath?: unknown } | null
       if (item !== null && typeof item === 'object' && typeof item.name === 'string' && typeof item.path === 'string') {
         const origin = (item as Record<string, unknown>).origin as { repo?: unknown; root?: unknown; ref?: unknown; commitSha?: unknown } | undefined
         const tagIds = (item as Record<string, unknown>).tagIds
-        trashByName.set(item.name, {
+        // 按 path 建索引：回收站里同名可以有多条（跨形态/先后两次入站），按名字
+        // 索引会让后一条静默覆盖前一条、把前一份目录留成谁都指不到的孤儿。
+        trashByPath.set(item.path, {
           name: item.name,
           path: item.path,
           movedAt: typeof item.movedAt === 'number' ? item.movedAt : 0,
@@ -294,5 +296,5 @@ export function hydrateMigratedState(migrated: MigratedStore): HydratedState {
   const collectionOrder = cleanStringList(migrated.collectionOrder)
   const sourceGroupOrder = cleanStringList(migrated.sourceGroupOrder)
 
-  return { entries, config, tagsById, sourcesByRepo, marketSources, trashByName, skillStats, marketStats, collectionOrder, sourceGroupOrder }
+  return { entries, config, tagsById, sourcesByRepo, marketSources, trashByPath, skillStats, marketStats, collectionOrder, sourceGroupOrder }
 }

package/src/store/store.ts

@@ -13,7 +13,7 @@ export class SkillHubStore {
   private tagsById = new Map<string, SkillTag>()
   private sourcesByRepo = new Map<string, SourceRecord>()
   private marketSources: MarketSourceRecord[] = []
-  private trashByName = new Map<string, TrashEntry>()
+  private trashByPath = new Map<string, TrashEntry>()
   private skillStats: SkillStatsCheckpoint | undefined = undefined
   private marketStats: MarketStatsSnapshot | undefined = undefined
   private collectionOrder: string[] = []
@@ -41,7 +41,7 @@ export class SkillHubStore {
         this.tagsById = state.tagsById
         this.sourcesByRepo = state.sourcesByRepo
         this.marketSources = state.marketSources
-        this.trashByName = state.trashByName
+        this.trashByPath = state.trashByPath
         this.skillStats = state.skillStats
         this.marketStats = state.marketStats
         this.collectionOrder = state.collectionOrder
@@ -444,26 +444,36 @@ export class SkillHubStore {
   /** All trashed skills, newest first. */
   async listTrash(): Promise<TrashEntry[]> {
     await this.ensureLoaded()
-    return [...this.trashByName.values()].sort((a, b) => b.movedAt - a.movedAt)
+    return [...this.trashByPath.values()].sort((a, b) => b.movedAt - a.movedAt)
   }
 
-  /** One trash entry by skill name (undefined when absent). */
+  /** One trash entry by skill name — the newest when a name has several. */
   async getTrash(name: string): Promise<TrashEntry | undefined> {
     await this.ensureLoaded()
-    return this.trashByName.get(name)
+    let newest: TrashEntry | undefined
+    for (const entry of this.trashByPath.values()) {
+      if (entry.name !== name) continue
+      if (newest === undefined || entry.movedAt > newest.movedAt) newest = entry
+    }
+    return newest
   }
 
-  /** Record a trashed skill. */
+  /**
+   * Record a trashed skill, keyed by its trashed path. Keying by name used to
+   * silently drop the previous record when the same name landed in the trash
+   * twice (a re-delete, or the two on-disk discovery forms), orphaning its
+   * directory with nothing left pointing at it.
+   */
   async addTrash(entry: TrashEntry): Promise<void> {
     await this.ensureLoaded()
-    this.trashByName.set(entry.name, entry)
+    this.trashByPath.set(entry.path, entry)
     await this.persist()
   }
 
-  /** Remove a trash record (after restore). */
-  async removeTrash(name: string): Promise<void> {
+  /** Remove a trash record by its trashed path (after restore or permanent clear). */
+  async removeTrash(path: string): Promise<void> {
     await this.ensureLoaded()
-    if (!this.trashByName.delete(name)) return
+    if (!this.trashByPath.delete(path)) return
     await this.persist()
   }
 
@@ -521,7 +531,7 @@ export class SkillHubStore {
         ...(this.tagsById.size > 0 ? { tags: [...this.tagsById.values()] } : {}),
         ...(this.sourcesByRepo.size > 0 ? { sources: [...this.sourcesByRepo.values()] } : {}),
         ...(this.marketSources.length > 0 ? { marketSources: [...this.marketSources] } : {}),
-        ...(this.trashByName.size > 0 ? { trash: [...this.trashByName.values()] } : {}),
+        ...(this.trashByPath.size > 0 ? { trash: [...this.trashByPath.values()] } : {}),
         ...(this.skillStats !== undefined ? { skillStats: this.skillStats } : {}),
         ...(this.marketStats !== undefined ? { marketStats: this.marketStats } : {}),
         ...(this.collectionOrder.length > 0 ? { collectionOrder: [...this.collectionOrder] } : {}),

package/src/store.test.ts

@@ -206,12 +206,28 @@ describe('SkillHubStore', () => {
     await store.addTrash({ name: 'older', path: '/tmp/.trash/older-1', movedAt: 10 })
     const trash = await store.listTrash()
     expect(trash.map((entry) => entry.name)).toEqual(['gone-skill', 'older']) // newest first
-    await store.removeTrash('gone-skill')
+    await store.removeTrash('/tmp/.trash/gone-skill-123')
     const reloaded = new SkillHubStore(file)
     expect(await reloaded.listTrash()).toHaveLength(1)
     expect(await reloaded.getTrash('older')).toMatchObject({ name: 'older' })
   })
 
+  it('keeps several trash entries sharing one skill name (no silent overwrite)', async () => {
+    // 同一个名字先后入站两次（重复删除，或磁盘上两种发现形态各进一次）：
+    // 按名字索引会让后一条覆盖前一条，前一份目录就成了谁都指不到的孤儿。
+    await store.addTrash({ name: 'dup', path: '/tmp/.trash/dup-1', movedAt: 1, sourcePath: '/tmp/skills/dup' })
+    await store.addTrash({ name: 'dup', path: '/tmp/.trash/dup.md.disabled-2', movedAt: 2, sourcePath: '/tmp/skills/dup.md.disabled' })
+    const reloaded = new SkillHubStore(file)
+    expect((await reloaded.listTrash()).map((entry) => entry.path).sort()).toEqual([
+      '/tmp/.trash/dup-1',
+      '/tmp/.trash/dup.md.disabled-2',
+    ])
+    // getTrash 按名字取最新的一条（恢复入口用）。
+    expect(await reloaded.getTrash('dup')).toMatchObject({ path: '/tmp/.trash/dup.md.disabled-2' })
+    await reloaded.removeTrash('/tmp/.trash/dup.md.disabled-2')
+    expect(await reloaded.getTrash('dup')).toMatchObject({ path: '/tmp/.trash/dup-1' })
+  })
+
   it('persists the trash source path', async () => {
     await store.addTrash({ name: 'flat-gone', path: '/tmp/.trash/flat-gone.md-1', movedAt: 7, sourcePath: '/tmp/skills/flat-gone.md' })
     const reloaded = new SkillHubStore(file)

package/src/update.ts

@@ -9,7 +9,7 @@
 
 import { createRequire } from 'node:module'
 import { errorText } from './error-text.ts'
-import { apiHeaders } from './repo.ts'
+import { apiHeaders, rateLimitResetAt } from './repo.ts'
 import type { UpdateCheckResponse } from './protocol.ts'
 
 /** Repository checked for releases. Keep in sync with package.json. */
@@ -63,11 +63,11 @@ export async function checkLatestRelease(repo = UPDATE_REPO, fetchImpl: typeof f
 
   if (!response.ok) {
     // Rate-limit exhaustion gets a friendlier message with the reset time.
-    const remaining = response.headers.get('x-ratelimit-remaining')
-    const reset = response.headers.get('x-ratelimit-reset')
-    if ((response.status === 403 || response.status === 429) && remaining === '0' && reset !== null) {
-      const at = new Date(Number(reset) * 1000)
-      return failure('github rate limit reached; retry after ' + at.toLocaleTimeString() + ' or set GITHUB_TOKEN')
+    // The header parsing lives in github-client so the repo layer and this
+    // check can never disagree on what counts as exhaustion.
+    const resetAt = rateLimitResetAt(response)
+    if (resetAt !== undefined) {
+      return failure('github rate limit reached; retry after ' + resetAt.toLocaleTimeString() + ' or set GITHUB_TOKEN')
     }
     return failure('GitHub HTTP ' + response.status)
   }