dsh-plugin-capabilities 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-capabilities",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Manage skills and MCP servers from the Web UI Settings. 在设置页管理 dsh 的技能与 MCP 服务器。",
   "type": "module",
   "main": "lib/index.js",
@@ -62,7 +62,7 @@
     "@deepseek-ai/cordis": "^4.0.1"
   },
   "dependencies": {
-    "@deepseek-ai/dsh-skill-filesystem": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-skill-filesystem": "^0.1.1-rc.1",
     "dompurify": "^3.4.13",
     "marked": "^18.0.10",
     "smol-toml": "^1.3.1",

package/src/repos.test.ts

@@ -5,6 +5,7 @@ import { join } from 'node:path'
 import { afterAll, describe, expect, it } from 'vitest'
 import { addGitRepo, addLocalRepo, detectSkillRoots, parseGitHubSource } from './repos.ts'
 import { loadState, removeSkillRoot } from './state.ts'
+import { removeTree } from './rmtree.ts'
 
 const root = mkdtempSync(join(tmpdir(), 'dsh-caps-repos-'))
 afterAll(() => rmSync(root, { recursive: true, force: true }))
@@ -129,8 +130,10 @@ describe('addLocalRepo', () => {
     expect(children).toHaveLength(1)
     expect(readFileSync(join(entry.roots[0], children[0], 'SKILL.md'), 'utf8')).toContain('solo')
 
-    // Removing the entry deletes the material dir but never the source.
-    expect(removeSkillRoot(entry.id, home)).toBe(true)
+    // Removing the entry deregisters; the caller then deletes the material
+    // dir (the junction wrapper) — never the linked source.
+    expect(removeSkillRoot(entry.id, home)).toMatchObject({ id: entry.id })
+    removeTree(entry.roots[0])
     expect(existsSync(entry.roots[0])).toBe(false)
     expect(existsSync(join(source, 'SKILL.md'))).toBe(true)
   })

package/src/repos.ts

@@ -8,8 +8,9 @@
  * provider.
  */
 
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, symlinkSync } from 'node:fs'
 import { basename, join, resolve } from 'node:path'
+import { removeTree } from './rmtree.ts'
 import { addSkillRoot, findRootByUrl, materialDirFor, newEntryId, type SkillRootEntry } from './state.ts'
 import { extractTarGz } from './tar.ts'
 
@@ -141,12 +142,12 @@ export async function addLocalRepo(path: string, dshHome?: string): Promise<Skil
     // the path in a dedicated directory holding a single link to it.
     const id = newEntryId('local')
     const material = materialDirFor(id, dshHome)
-    rmSync(material, { recursive: true, force: true })
+    removeTree(material)
     mkdirSync(material, { recursive: true })
     try {
       symlinkSync(resolved, join(material, 'skill'), process.platform === 'win32' ? 'junction' : 'dir')
     } catch {
-      rmSync(material, { recursive: true, force: true })
+      removeTree(material)
       throw new Error('single-skill local folders need a directory link; try adding their parent folder instead')
     }
     return addSkillRoot({ id, kind: 'local', label: basename(resolved), path: resolved, roots: [material], materialDir: material }, dshHome)
@@ -175,7 +176,7 @@ export async function addGitRepo(
 
   const id = newEntryId('git')
   const material = materialDirFor(id, options.dshHome)
-  rmSync(material, { recursive: true, force: true })
+  removeTree(material)
   const checkout = join(material, 'repo')
   try {
     mkdirSync(checkout, { recursive: true })
@@ -192,7 +193,7 @@ export async function addGitRepo(
       options.dshHome,
     )
   } catch (error) {
-    rmSync(material, { recursive: true, force: true })
+    removeTree(material)
     throw error
   }
 }

package/src/rmtree.test.ts

@@ -0,0 +1,26 @@
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterAll, describe, expect, it } from 'vitest'
+import { removeTree } from './rmtree.ts'
+
+const root = mkdtempSync(join(tmpdir(), 'dsh-caps-rmtree-'))
+afterAll(() => rmSync(root, { recursive: true, force: true }))
+
+describe('removeTree', () => {
+  it('deletes a tree holding read-only files and folders', () => {
+    const dir = join(root, 'readonly')
+    mkdirSync(join(dir, 'nested'), { recursive: true })
+    writeFileSync(join(dir, 'nested', 'SKILL.md'), '---\nname: ro\n---\n')
+    // Read-only entries are the Windows EPERM source: plain rmSync cannot
+    // unlink them, removeTree clears the attribute before removing.
+    chmodSync(join(dir, 'nested', 'SKILL.md'), 0o444)
+    chmodSync(join(dir, 'nested'), 0o555)
+    removeTree(dir)
+    expect(existsSync(dir)).toBe(false)
+  })
+
+  it('treats a missing path as done (force semantics)', () => {
+    expect(() => removeTree(join(root, 'never-existed'))).not.toThrow()
+  })
+})

package/src/rmtree.ts

@@ -0,0 +1,46 @@
+/**
+ * Windows-hardened recursive delete for repository material. The skill
+ * provider watches these trees live, and antivirus or search indexers
+ * briefly hold handles onto freshly written files, so a plain rmSync
+ * races open handles and dies with EPERM. Two mitigations: clear the
+ * read-only attribute first (unlinking a read-only entry fails on
+ * Windows), then retry the removal so short-lived locks run out.
+ */
+
+import { chmodSync, readdirSync, rmSync, type Dirent } from 'node:fs'
+import { join } from 'node:path'
+
+/** Windows lock holders usually let go within a second or two. */
+const RETRIES = { maxRetries: 10, retryDelay: 200 } as const
+
+function clearReadOnly(dir: string): void {
+  let entries: Dirent[]
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return // unreadable: rmSync will surface the real error
+  }
+  for (const entry of entries) {
+    const child = join(dir, entry.name)
+    // Links read as neither file nor directory here; chmod would hit the
+    // link TARGET (possibly the user's own folder), so they are skipped —
+    // rmSync removes the link itself without following it.
+    if (entry.isDirectory()) {
+      try { chmodSync(child, 0o777) } catch { /* racing delete */ }
+      clearReadOnly(child)
+    } else if (entry.isFile()) {
+      try { chmodSync(child, 0o666) } catch { /* racing delete */ }
+    }
+  }
+  try { chmodSync(dir, 0o777) } catch { /* racing delete */ }
+}
+
+/** Delete one directory tree (or lone file), tolerating Windows lock races. */
+export function removeTree(path: string): void {
+  try {
+    clearReadOnly(path)
+  } catch {
+    // walk failure: rmSync reports the underlying error anyway
+  }
+  rmSync(path, { recursive: true, force: true, ...RETRIES })
+}

package/src/routes.ts

@@ -11,6 +11,7 @@ import { addGitRepo, addLocalRepo, rootExists } from './repos.ts'
 import { dshLaunch, restartOwnedByShell, scheduleRestart, trustedRestartRequest } from './restart.ts'
 import { deleteSkill, setSkillPolicy, updateSkillFile, userSkillsDir, validateSkillInput, writeSkill, type SkillInput } from './skills.ts'
 import { findRootByUrl, loadState, pluginStateDir, removeSkillRoot, type SkillRootEntry } from './state.ts'
+import { removeTree } from './rmtree.ts'
 import { listMcp, removeMcp, setMcpDisabled, upsertMcp, validateMcpInput, type McpInput } from './mcp.ts'
 import type { CapabilitiesHost, HostSkill } from './types.ts'
 
@@ -354,12 +355,17 @@ export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: Capabili
             sendJson(response, 400, { error: 'id is required' })
             return
           }
-          const ok = removeSkillRoot(body.id)
-          if (!ok) {
+          const removed = removeSkillRoot(body.id)
+          if (removed === undefined) {
             sendJson(response, 404, { error: 'repository not found' })
             return
           }
+          // Unwatch before unlink: the provider's directory watchers hold
+          // handles on the material tree, and removing a watched tree on
+          // Windows fails with EPERM (the state is already saved by then,
+          // which is why the repo still disappears despite the error).
           await config.remountProvider()
+          if (removed.materialDir !== undefined) removeTree(removed.materialDir)
           sendJson(response, 200, { ok: true })
         } catch (error) {
           sendJson(response, 500, { error: error instanceof Error ? error.message : String(error) })

package/src/state.test.ts

@@ -3,6 +3,7 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterAll, describe, expect, it } from 'vitest'
 import { addSkillRoot, findRootByUrl, loadState, materialDirFor, newEntryId, removeSkillRoot, saveState } from './state.ts'
+import { removeTree } from './rmtree.ts'
 
 const root = mkdtempSync(join(tmpdir(), 'dsh-caps-state-'))
 afterAll(() => rmSync(root, { recursive: true, force: true }))
@@ -23,8 +24,8 @@ describe('state round-trip', () => {
     expect(findRootByUrl('a/b', home)?.id).toBe(entry.id)
     expect(findRootByUrl('other/repo', home)).toBeUndefined()
 
-    expect(removeSkillRoot(entry.id, home)).toBe(true)
-    expect(removeSkillRoot(entry.id, home)).toBe(false)
+    expect(removeSkillRoot(entry.id, home)).toMatchObject({ id: entry.id })
+    expect(removeSkillRoot(entry.id, home)).toBeUndefined()
     expect(loadState(home).skillRoots).toHaveLength(0)
   })
 
@@ -55,7 +56,11 @@ describe('removeSkillRoot with link material', () => {
     symlinkSync(source, join(material, 'skill'), process.platform === 'win32' ? 'junction' : 'dir')
     addSkillRoot({ id, kind: 'local', label: 'keep', path: source, roots: [material], materialDir: material }, home)
 
-    expect(removeSkillRoot(id, home)).toBe(true)
+    // Deregistration only drops the state row; the caller deletes the
+    // material itself once the provider stopped watching it.
+    expect(removeSkillRoot(id, home)).toMatchObject({ id })
+    expect(existsSync(material)).toBe(true)
+    removeTree(material)
     expect(existsSync(material)).toBe(false)
     expect(existsSync(join(source, 'SKILL.md'))).toBe(true)
     // State file persisted without the entry.

package/src/state.ts

@@ -5,7 +5,7 @@
  * off this file, so it stays small, JSON, and hand-recoverable.
  */
 
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { randomBytes } from 'node:crypto'
@@ -90,17 +90,21 @@ export function addSkillRoot(entry: Omit<SkillRootEntry, 'addedAt'>, dshHome?: s
   return stored
 }
 
-/** Remove one entry by id and delete its material dir. Returns false when absent. */
-export function removeSkillRoot(id: string, dshHome?: string): boolean {
+/**
+ * Deregister one entry by id and persist immediately. The material dir is
+ * deliberately NOT deleted here: the skill provider still watches it, and
+ * removing a watched tree on Windows fails with EPERM even though the
+ * state is already saved. The caller unmounts (remountProvider) first,
+ * then runs removeTree over the returned entry's materialDir. Returns the
+ * removed entry, or undefined when the id is unknown.
+ */
+export function removeSkillRoot(id: string, dshHome?: string): SkillRootEntry | undefined {
   const state = loadState(dshHome)
   const at = state.skillRoots.findIndex(entry => entry.id === id)
-  if (at === -1) return false
+  if (at === -1) return undefined
   const [removed] = state.skillRoots.splice(at, 1)
   saveState(state, dshHome)
-  if (removed.materialDir !== undefined) {
-    rmSync(removed.materialDir, { recursive: true, force: true, maxRetries: 2 })
-  }
-  return true
+  return removed
 }
 
 /** Whether a git URL is already registered (market “installed” state). */