dsh-skill-hub 0.2.6 → 0.3.0

package/src/index.ts

@@ -21,6 +21,10 @@ import { SkillHubProvider } from './provider.ts'
 import { makeRoutes } from './routes.ts'
 import { createSkillStatsReader, type SkillStatsReader } from './stats.ts'
 import { SkillHubStore } from './store.ts'
+import { cleanupLeftoverImportDirs } from './repo.ts'
+import { dshHome } from './store.ts'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
 
 /** Stable cordis plugin name (matches cordis.patch.yml insert id). */
 export const name = 'skill-hub'
@@ -213,6 +217,20 @@ export function apply(ctx: Context, config?: Config): void {
   // build seeds the settings namespace from the saved sidecar config when the
   // namespace has no user section yet. Later edits live only in the settings
   // document; the sidecar keeps its (now-stale) copy untouched.
+  // Startup: 清理 Issue #3 遗留的 .*.import-* 临时目录（尽早回收，不阻塞）
+  void (async () => {
+    const home = dshHome()
+    const agentsHome = process.env.DSH_AGENTS_HOME ?? join(homedir(), '.agents')
+    for (const root of [join(home, 'skills'), join(agentsHome, 'skills')]) {
+      try {
+        const c = await cleanupLeftoverImportDirs(root)
+        if (c > 0) ctx.logger.info(`[dsh-skill-hub] startup cleaned ${c} leftover import temp dir(s) in ${root}`)
+      } catch (error) {
+        ctx.logger.warn('[dsh-skill-hub] startup cleanup failed', error)
+      }
+    }
+  })()
+
   void (async () => {
     const legacy = await store.getConfig()
     if (Object.keys(legacy).length > 0 && Object.keys(saved()).length === 0) {

package/src/protocol.ts

@@ -23,11 +23,16 @@ export const SKILL_HUB_API = {
   marketSync: '/api/skill-hub/market/source/sync',
   repo: '/api/skill-hub/repo',
   repoImport: '/api/skill-hub/repo/import',
+  repoImportProgress: '/api/skill-hub/repo/import/progress',
+  repoImportCancel: '/api/skill-hub/repo/import/cancel',
   update: '/api/skill-hub/update',
   groups: '/api/skill-hub/groups',
   tag: '/api/skill-hub/tag',
   tagDelete: '/api/skill-hub/tag/delete',
   tagMembers: '/api/skill-hub/tag/members',
+  tagReorder: '/api/skill-hub/tag/reorder',
+  collectionReorder: '/api/skill-hub/collections/reorder',
+  sourceGroupReorder: '/api/skill-hub/source-groups/reorder',
   sources: '/api/skill-hub/sources',
   sourceCheck: '/api/skill-hub/sources/check',
   sourceSync: '/api/skill-hub/sources/sync',
@@ -414,7 +419,7 @@ export interface MarketSyncResponse {
   skills: string[]
 }
 
-/** A skill discovered in a GitHub repo under skills/ or design-templates/. */
+/** A skill discovered in a GitHub repo under any top-level root (e.g. skills/, templates/). */
 export interface RepoSkillEntry {
   /** Kebab-case skill name (directory basename). */
   name: string
@@ -434,8 +439,8 @@ export interface RepoSkillEntry {
   existing: boolean
 }
 
-/** Supported skill roots in a GitHub repo. */
-export type RepoRoot = 'skills' | 'design-templates'
+/** Skill root in a GitHub repo: the top-level directory that contains skills (e.g. skills, design-templates, templates). Auto-derived from SKILL.md locations, not hard-coded. */
+export type RepoRoot = string
 
 /** GET /api/skill-hub/repo — discover importable skills in a GitHub repo. */
 export interface RepoDiscoverResponse {
@@ -461,8 +466,49 @@ export interface RepoImportRequest {
   ref?: string
 }
 
-/** POST /api/skill-hub/repo/import */
+/** POST /api/skill-hub/repo/import — now creates an async job (B方案) */
 export interface RepoImportResponse {
+  ok: true
+  jobId: string
+  total: number
+  totalBytes: number
+}
+
+/** GET /api/skill-hub/repo/import/progress?jobId=xxx */
+export interface RepoImportProgressResponse {
+  ok: true
+  jobId: string
+  status: 'running' | 'done' | 'cancelled' | 'error'
+  total: number
+  done: number
+  /** 当前正在下载的 skill 名，done < total 时有效 */
+  current?: string
+  /** 当前正在下载的文件路径（相对 skill dir） */
+  currentFile?: string
+  /** 字节级进度 */
+  totalBytes: number
+  downloadedBytes: number
+  /** 下载速度 bytes/sec，running 时有效 */
+  bytesPerSecond?: number
+  imported: Array<{ name: string; origin: string; path: string }>
+  skipped: Array<{ name: string; reason: 'exists' }>
+  failed: Array<{ name: string; error: string }>
+  /** error 状态时的原因 */
+  error?: string
+}
+
+/** POST /api/skill-hub/repo/import/cancel */
+export interface RepoImportCancelRequest {
+  jobId: string
+}
+export interface RepoImportCancelResponse {
+  ok: true
+  jobId: string
+  status: 'cancelled' | 'done'
+}
+
+/** @deprecated 旧同步响应，保留供类型兼容，实际已由 Progress 代替 */
+export interface RepoImportLegacyResponse {
   ok: true
   imported: Array<{ name: string; origin: string; path: string }>
   skipped: Array<{ name: string; reason: 'exists' }>
@@ -507,12 +553,16 @@ export interface CollectionGroup {
 /** GET /api/skill-hub/groups */
 export interface GroupsResponse {
   ok: true
-  /** 用户自定义 tag 分组（按创建顺序）。 */
+  /** 用户自定义 tag 分组（按拖拽顺序）。 */
   tags: SkillTag[]
-  /** 系统集合组（按 origin 聚合，名称排序）。 */
+  /** 系统集合组（按拖拽顺序，兜底按名称）。 */
   collections: CollectionGroup[]
   /** skillName → 集合名 的完整映射。 */
   origins: Record<string, string>
+  /** 来源分组整体顺序（project / col:xxx / uncategorized-source），用于 SourcesView 顶层排序 */
+  sourceGroupOrder?: string[]
+  /** 兼容旧 collectionOrder 字段 */
+  collectionOrder?: string[]
 }
 
 /** POST /api/skill-hub/tag — 新建（缺省 id）或重命名（带 id）。 */
@@ -554,6 +604,39 @@ export interface TagMembersResponse {
   tags: SkillTag[]
 }
 
+/** POST /api/skill-hub/tag/reorder — 拖拽重排场景分组 */
+export interface TagReorderRequest {
+  /** 按新顺序排列的 tag id 列表（需包含全部 id） */
+  orderedIds: string[]
+}
+/** POST /api/skill-hub/tag/reorder */
+export interface TagReorderResponse {
+  ok: true
+  tags: SkillTag[]
+}
+
+/** POST /api/skill-hub/collections/reorder — 拖拽重排来源集合 */
+export interface CollectionReorderRequest {
+  /** 按新顺序排列的集合名列表（需包含全部 name） */
+  orderedNames: string[]
+}
+/** POST /api/skill-hub/collections/reorder */
+export interface CollectionReorderResponse {
+  ok: true
+  collections: CollectionGroup[]
+  order: string[]
+}
+
+/** POST /api/skill-hub/source-groups/reorder — 拖拽重排来源顶层分组（project / collections / personal） */
+export interface SourceGroupReorderRequest {
+  /** 按新顺序排列的顶层分组 key 列表（project / col:xxx / uncategorized-source） */
+  orderedKeys: string[]
+}
+export interface SourceGroupReorderResponse {
+  ok: true
+  order: string[]
+}
+
 /** 来源跟踪记录：一组来自同一上游仓库根目录的技能。 */
 export interface SourceRecord {
   /** GitHub owner/repo。 */

package/src/repo.test.ts

@@ -40,10 +40,16 @@ describe('originForRoot', () => {
   })
 
   it('splits by root when multiple roots are present', () => {
-    const roots = new Set(['skills', 'design-templates'] as const)
+    const roots = new Set(['skills', 'design-templates'])
     expect(originForRoot('nexu-io/open-design', roots, 'skills')).toBe('nexu-io/open-design/skills')
     expect(originForRoot('nexu-io/open-design', roots, 'design-templates')).toBe('nexu-io/open-design/design-templates')
   })
+
+  it('works with arbitrary roots', () => {
+    const roots = new Set(['templates', 'workflows'])
+    expect(originForRoot('a/b', roots, 'templates')).toBe('a/b/templates')
+    expect(originForRoot('a/b', new Set(['my-root']), 'my-root')).toBe('a/b')
+  })
 })
 
 describe('collectRepoSkillFiles', () => {
@@ -59,7 +65,7 @@ describe('collectRepoSkillFiles', () => {
 })
 
 describe('discoverRepoEntries', () => {
-  it('discovers skills and design-templates and computes origins/sizes', () => {
+  it('discovers skills and design-templates and computes origins/sizes (generic roots)', () => {
     const tree = [
       blob('skills/engineering/code-review/SKILL.md', 10),
       blob('skills/engineering/code-review/README.md', 5),
@@ -70,55 +76,85 @@ describe('discoverRepoEntries', () => {
       blob('plugins/examples/foo/SKILL.md', 99),
     ]
     const entries = discoverRepoEntries(tree, 'nexu-io/open-design', new Set(['tdd']))
-    expect(entries.map((entry) => entry.name)).toEqual(['code-review', 'dashboard', 'tdd'])
-    expect(entries[0].origin).toBe('nexu-io/open-design/skills')
-    expect(entries[0].fileCount).toBe(2)
-    expect(entries[0].totalBytes).toBe(15)
-    expect(entries[1].origin).toBe('nexu-io/open-design/design-templates')
-    expect(entries[1].fileCount).toBe(2)
-    expect(entries[1].totalBytes).toBe(109)
-    expect(entries[2].existing).toBe(true)
+    // generic: any top-level dir is a root, so docs/plugins are also discovered (4 roots -> split origins)
+    expect(entries.map((entry) => entry.name)).toEqual(['code-review', 'dashboard', 'example', 'foo', 'tdd'])
+    expect(entries.find((e) => e.name === 'code-review')?.origin).toBe('nexu-io/open-design/skills')
+    expect(entries.find((e) => e.name === 'code-review')?.fileCount).toBe(2)
+    expect(entries.find((e) => e.name === 'code-review')?.totalBytes).toBe(15)
+    expect(entries.find((e) => e.name === 'dashboard')?.origin).toBe('nexu-io/open-design/design-templates')
+    expect(entries.find((e) => e.name === 'dashboard')?.fileCount).toBe(2)
+    expect(entries.find((e) => e.name === 'dashboard')?.totalBytes).toBe(109)
+    expect(entries.find((e) => e.name === 'example')?.origin).toBe('nexu-io/open-design/docs')
+    expect(entries.find((e) => e.name === 'foo')?.origin).toBe('nexu-io/open-design/plugins')
+    expect(entries.find((e) => e.name === 'tdd')?.existing).toBe(true)
+  })
+
+  it('discovers arbitrary roots like templates and workflows', () => {
+    const tree = [
+      blob('templates/my-template/SKILL.md', 10),
+      blob('workflows/deploy/SKILL.md', 7),
+      blob('my-skills/foo/SKILL.md', 5),
+    ]
+    const entries = discoverRepoEntries(tree, 'a/b')
+    expect(entries.map((e) => e.root).sort()).toEqual(['my-skills', 'templates', 'workflows'])
+    expect(entries.map((e) => e.name).sort()).toEqual(['deploy', 'foo', 'my-template'])
+  })
+
+  it('ignores hidden roots and bare SKILL.md at depth 1', () => {
+    const tree = [
+      blob('.hidden/secret/SKILL.md', 1),
+      blob('SKILL.md', 1),
+      blob('skills/SKILL.md', 1),
+      blob('.github/workflows/ci/SKILL.md', 1),
+    ]
+    expect(discoverRepoEntries(tree, 'a/b')).toEqual([])
   })
 
-  it('returns empty when no supported SKILL.md exists', () => {
+  it('returns empty when no SKILL.md exists', () => {
     expect(discoverRepoEntries([blob('README.md'), blob('skills/foo/README.md')], 'a/b')).toEqual([])
   })
 })
 
 describe('skillDirOf', () => {
   it('recovers the nested upstream directory from the manifest', () => {
-    const source = { root: 'skills' as const, manifest: { 'skills/engineering/ask-matt/SKILL.md': 100, 'skills/engineering/ask-matt/OTHER.md': 5 } }
+    const source = { root: 'skills', manifest: { 'skills/engineering/ask-matt/SKILL.md': 100, 'skills/engineering/ask-matt/OTHER.md': 5 } }
     expect(skillDirOf(source, 'ask-matt')).toBe('skills/engineering/ask-matt')
   })
 
   it('finds the skill in the upstream tree when the manifest lacks an entry', () => {
-    const source = { root: 'skills' as const }
+    const source = { root: 'skills' }
     const paths = ['skills/engineering/grill-with-docs/SKILL.md', 'skills/engineering/grill-with-docs/agents/openai.yaml']
     expect(skillDirOf(source, 'grill-with-docs', paths)).toBe('skills/engineering/grill-with-docs')
   })
 
   it('prefers the top-level-root match over a same-name skill elsewhere', () => {
-    const source = { root: 'skills' as const }
+    const source = { root: 'skills' }
     const paths = ['docs/engineering/a/SKILL.md', 'skills/misc/a/SKILL.md']
     expect(skillDirOf(source, 'a', paths)).toBe('skills/misc/a')
   })
 
   it('follows an upstream move away from the manifest path', () => {
-    const source = { root: 'skills' as const, manifest: { 'skills/old/ask-matt/SKILL.md': 100 } }
+    const source = { root: 'skills', manifest: { 'skills/old/ask-matt/SKILL.md': 100 } }
     const paths = ['skills/new/ask-matt/SKILL.md']
     expect(skillDirOf(source, 'ask-matt', paths)).toBe('skills/new/ask-matt')
   })
 
   it('falls back to root/name without a manifest entry or tree', () => {
-    const source = { root: 'skills' as const }
+    const source = { root: 'skills' }
     expect(skillDirOf(source, 'plain')).toBe('skills/plain')
   })
+
+  it('works with arbitrary roots', () => {
+    const source = { root: 'templates', manifest: { 'templates/my-tmpl/SKILL.md': 10 } }
+    expect(skillDirOf(source, 'my-tmpl')).toBe('templates/my-tmpl')
+    expect(skillDirOf({ root: 'workflows' }, 'deploy', ['workflows/deploy/SKILL.md'])).toBe('workflows/deploy')
+  })
 })
 
 describe('diffRemoteSkills', () => {
   it('matches nested skills via the manifest and reports real deletions only', () => {
     const source = {
-      root: 'skills' as const,
+      root: 'skills',
       skills: ['ask-matt', 'gone'],
       manifest: {
         'skills/engineering/ask-matt/SKILL.md': 100,
@@ -134,15 +170,21 @@ describe('diffRemoteSkills', () => {
   })
 
   it('does not report skills missing from the manifest as deleted when the tree has them', () => {
-    const source = { root: 'skills' as const, skills: ['grill-with-docs'] }
+    const source = { root: 'skills', skills: ['grill-with-docs'] }
     const tree = [blob('skills/engineering/grill-with-docs/SKILL.md', 100)]
     expect(diffRemoteSkills(tree, source)).toEqual({ updated: ['grill-with-docs'], deleted: [] })
   })
 
   it('reports size changes as updated', () => {
-    const source = { root: 'skills' as const, skills: ['a'], manifest: { 'skills/engineering/a/SKILL.md': 100 } }
+    const source = { root: 'skills', skills: ['a'], manifest: { 'skills/engineering/a/SKILL.md': 100 } }
     expect(diffRemoteSkills([blob('skills/engineering/a/SKILL.md', 120)], source)).toEqual({ updated: ['a'], deleted: [] })
   })
+
+  it('works with arbitrary roots', () => {
+    const source = { root: 'templates', skills: ['x'], manifest: { 'templates/x/SKILL.md': 10 } }
+    expect(diffRemoteSkills([blob('templates/x/SKILL.md', 11)], source)).toEqual({ updated: ['x'], deleted: [] })
+    expect(diffRemoteSkills([], source)).toEqual({ updated: [], deleted: ['x'] })
+  })
 })
 
 describe('downloadRepoSkill', () => {

package/src/repo.ts

@@ -2,9 +2,9 @@
  * GitHub repository skill discovery/import helpers.
  *
  * Kept dependency-free and mostly pure so the root/origin rules are easy to
- * test. The two supported roots mirror the repositories we care about:
- * `skills/**` (standard skill bundles) and `design-templates/**` (template
- * skill bundles in nexu-io/open-design).
+ * test. Roots are auto-derived: any top-level directory that contains a
+ * `**\/SKILL.md` (e.g. `skills/**`, `design-templates/**`, `templates/**`,
+ * `workflows/**`) is treated as a skill root. No hard-coded allowlist.
  */
 
 import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises'
@@ -13,9 +13,12 @@ import { isSkillName } from '@deepseek-ai/dsh-skill'
 import type { RepoRoot, RepoSkillEntry } from './protocol.ts'
 import { parseFrontmatter } from './skillfs.ts'
 
-/** Supported skill roots in a GitHub repo. */
+/** Preferred display order for known roots; unknown roots sort alphabetically after these. */
 export const REPO_ROOTS: readonly RepoRoot[] = ['skills', 'design-templates']
 
+/** Top-level directory pattern for a skill root: visible, non-dot, safe chars. First char must be alphanum. */
+const ROOT_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/
+
 /** Parsed GitHub repository reference. */
 export interface RepoRef {
   owner: string
@@ -180,20 +183,25 @@ export function collectRepoSkillFiles(tree: readonly RepoTreeItem[], dir: string
 }
 
 /** Compute an origin collection name. Multiple roots split by root, one root keeps the repo slug. */
-export function originForRoot(repo: string, rootsPresent: ReadonlySet<RepoRoot>, root: RepoRoot): string {
+export function originForRoot(repo: string, rootsPresent: ReadonlySet<string>, root: string): string {
   return rootsPresent.size > 1 ? `${repo}/${root}` : repo
 }
 
-/** Discover importable skills from a repo tree. Invalid names are ignored. */
+/** Discover importable skills from a repo tree. Invalid names are ignored. Roots are auto-derived from the top-level directory of each SKILL.md. */
 export function discoverRepoEntries(tree: readonly RepoTreeItem[], repo: string, existingNames: ReadonlySet<string> = new Set()): RepoSkillEntry[] {
   const candidates: Array<{ root: RepoRoot; dir: string; name: string; path: string }> = []
-  const rootsPresent = new Set<RepoRoot>()
+  const rootsPresent = new Set<string>()
   for (const item of tree) {
     if (item.type !== 'blob') continue
-    const match = /^(skills|design-templates)\/(.+)\/SKILL\.md$/.exec(item.path)
-    if (match === null) continue
-    const root = match[1] as RepoRoot
+    // Any SKILL.md at depth >=2: top segment is the root, last segment is the skill name (may be nested like root/category/name/SKILL.md)
+    const slash = item.path.indexOf('/')
+    if (slash === -1) continue
+    if (!item.path.endsWith('/SKILL.md')) continue
+    const root = item.path.slice(0, slash)
+    if (!ROOT_RE.test(root)) continue
     const dir = item.path.slice(0, -'/SKILL.md'.length)
+    // dir must be at least root/name (reject bare root/SKILL.md)
+    if (dir === root || dir.length <= root.length + 1) continue
     const name = dir.slice(dir.lastIndexOf('/') + 1)
     if (!isSkillName(name)) continue
     rootsPresent.add(root)
@@ -231,28 +239,37 @@ export async function mapConcurrent<T, R>(items: readonly T[], limit: number, wo
   return results
 }
 
+/** Whether an error is an abort (AbortError / signal). */
+export function isAbortError(error: unknown): boolean {
+  return error instanceof Error && (error.name === 'AbortError' || error.message.includes('aborted') || error.message.includes('Abort'))
+}
+
 /**
  * Download one GitHub file as a buffer. Tries raw.githubusercontent.com
  * first (no API quota); on any failure falls back to the api.github.com
  * contents endpoint with the raw media type (rate-limited, but reachable
  * from networks that block the raw host).
  */
-export async function downloadGitHubFile(repo: string, ref: string, path: string, fetchImpl: typeof fetch = fetch): Promise<Buffer> {
+export async function downloadGitHubFile(repo: string, ref: string, path: string, fetchImpl: typeof fetch = fetch, signal?: AbortSignal): Promise<Buffer> {
+  if (signal?.aborted) throw new DOMException('aborted', 'AbortError')
   const encodedPath = path.split('/').map((segment) => encodeURIComponent(segment)).join('/')
   const rawUrl = `https://raw.githubusercontent.com/${repo}/${encodeURIComponent(ref)}/${encodedPath}`
   let firstError: string | null = null
   let response: Response | null = null
   try {
-    response = await fetchImpl(rawUrl, { headers: githubAuthHeaders() })
+    response = await fetchImpl(rawUrl, { headers: githubAuthHeaders(), ...(signal !== undefined ? { signal } : {}) })
   } catch (error) {
+    if (isAbortError(error)) throw error
     firstError = error instanceof Error ? error.message : String(error)
   }
   if (response === null || !response.ok) {
+    if (signal?.aborted) throw new DOMException('aborted', 'AbortError')
     // Fallback: api.github.com/contents with the raw media type.
     const apiUrl = `https://api.github.com/repos/${repo}/contents/${encodedPath}`
     try {
-      response = await fetchImpl(apiUrl, { headers: { accept: 'application/vnd.github.raw', ...githubAuthHeaders() } })
+      response = await fetchImpl(apiUrl, { headers: { accept: 'application/vnd.github.raw', ...githubAuthHeaders() }, ...(signal !== undefined ? { signal } : {}) })
     } catch (error) {
+      if (isAbortError(error)) throw error
       throw new RepoFetchError('download failed: ' + (firstError ?? (error instanceof Error ? error.message : String(error))))
     }
   }
@@ -262,6 +279,7 @@ export async function downloadGitHubFile(repo: string, ref: string, path: string
   try {
     return Buffer.from(await response.arrayBuffer())
   } catch (error) {
+    if (isAbortError(error)) throw error
     throw new RepoFetchError('download read failed: ' + (error instanceof Error ? error.message : String(error)))
   }
 }
@@ -278,22 +296,30 @@ export async function downloadRepoSkill(
   files: readonly RepoFile[],
   targetRoot: string,
   fetchImpl: typeof fetch = fetch,
+  signal?: AbortSignal,
+  onProgress?: (bytes: number, file: string) => void,
 ): Promise<{ targetDir: string; skillPath: string }> {
+  if (signal?.aborted) throw new DOMException('aborted', 'AbortError')
   const targetDir = join(targetRoot, entry.name)
   await mkdir(targetRoot, { recursive: true })
   // Dot-prefixed so a leftover temp dir can never surface as a skill in the
   // provider's discovery scan (scanRoot skips dot entries).
   const tempDir = await mkdtemp(join(targetRoot, '.' + entry.name + '.import-'))
+  let renamed = false
   try {
     await mapConcurrent(files, 6, async (file) => {
+      if (signal?.aborted) throw new DOMException('aborted', 'AbortError')
       const relative = file.path.slice(entry.dir.length + 1)
       if (relative === '' || relative.includes('..')) throw new RepoFetchError('unsafe repo path: ' + file.path)
       const target = join(tempDir, relative)
-      const buffer = await downloadGitHubFile(repo, ref, file.path, fetchImpl)
+      const buffer = await downloadGitHubFile(repo, ref, file.path, fetchImpl, signal)
       await mkdir(dirname(target), { recursive: true })
       await writeFile(target, buffer)
+      onProgress?.(buffer.length, relative)
     })
 
+    if (signal?.aborted) throw new DOMException('aborted', 'AbortError')
+
     let text: string
     try {
       text = await readFile(join(tempDir, 'SKILL.md'), 'utf8')
@@ -307,16 +333,53 @@ export async function downloadRepoSkill(
     }
 
     await rename(tempDir, targetDir)
+    renamed = true
     return { targetDir, skillPath: join(targetDir, 'SKILL.md') }
   } catch (error) {
-    // Concurrent workers may still be writing when the batch fails; retry
-    // the cleanup once after a beat before giving up.
-    await rm(tempDir, { recursive: true, force: true }).catch(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 60))
-      await rm(tempDir, { recursive: true, force: true }).catch(() => {})
-    })
     throw error
+  } finally {
+    if (!renamed) {
+      // 尽力清理临时目录，失败只打日志，不再静默吞掉；finally 保证 abort/异常都能清理
+      try {
+        await rm(tempDir, { recursive: true, force: true })
+      } catch (firstError) {
+        // 并发 worker 可能仍在写入，稍等 60ms 重试一次
+        await new Promise((resolve) => setTimeout(resolve, 60))
+        try {
+          await rm(tempDir, { recursive: true, force: true })
+        } catch (secondError) {
+          console.warn(`[skill-hub] cleanup tempDir failed ${tempDir}:`, secondError instanceof Error ? secondError.message : String(secondError), 'first:', firstError instanceof Error ? firstError.message : String(firstError))
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 启动时扫描并清理残留的 `.*.import-*` 临时目录（Issue #3 第4点）。
+ * 越积越多的点前缀目录不会显示为 skill，但会占空间，尽早回收。
+ */
+export async function cleanupLeftoverImportDirs(targetRoot: string): Promise<number> {
+  const { readdir, rm: rm2 } = await import('node:fs/promises')
+  let names: string[]
+  try {
+    names = await readdir(targetRoot)
+  } catch {
+    return 0
+  }
+  let cleaned = 0
+  for (const name of names) {
+    if (!/^\..*\.import-/.test(name)) continue
+    const full = join(targetRoot, name)
+    try {
+      await rm2(full, { recursive: true, force: true })
+      cleaned += 1
+    } catch (error) {
+      console.warn(`[skill-hub] startup cleanup failed ${full}:`, error instanceof Error ? error.message : String(error))
+    }
   }
+  if (cleaned > 0) console.warn(`[skill-hub] startup cleaned ${cleaned} leftover import temp dir(s) in ${targetRoot}`)
+  return cleaned
 }
 
 // ------------------------------------------------------- source tracking
@@ -447,7 +510,7 @@ export function skillManifest(tree: readonly RepoTreeItem[], dir: string): Recor
  * resilient to incomplete manifests and upstream moves.
  */
 export function skillDirOf(
-  source: { root: RepoRoot; manifest?: Record<string, number> },
+  source: { root: string; manifest?: Record<string, number> },
   name: string,
   treePaths?: readonly string[],
 ): string {
@@ -473,7 +536,7 @@ export function skillDirOf(
  */
 export function diffRemoteSkills(
   tree: readonly RepoTreeItem[],
-  source: { root: RepoRoot; skills: readonly string[]; manifest?: Record<string, number> },
+  source: { root: string; skills: readonly string[]; manifest?: Record<string, number> },
 ): { updated: string[]; deleted: string[] } {
   const blobs = new Map<string, number>()
   for (const item of tree) {
@@ -513,7 +576,7 @@ export function diffRemoteSkills(
 }
 
 /** Minimal RepoSkillEntry for a tracked skill name (sync re-downloads by name). */
-export function repoSkillEntry(name: string, root: RepoRoot, repo: string): RepoSkillEntry {
+export function repoSkillEntry(name: string, root: string, repo: string): RepoSkillEntry {
   return {
     name,
     dir: root + '/' + name,

package/src/routes.test.ts

@@ -488,7 +488,7 @@ describe('skill-hub routes', () => {
     expect((del.json() as import('./protocol.ts').MarketSourceResponse).repos).toEqual([{ repo: 'other/repo', ref: 'v2.0.0' }])
   })
 
-  // ------------------------------------------------------- repo import
+  // ------------------------------------------------------- repo import (B方案 job+轮询)
   it('imports repo skills and records the upstream source', async () => {
     const skillMd = '---\nname: code-review\ndescription: Reviews code\n---\n\nbody'
     stubFetch([
@@ -506,9 +506,23 @@ describe('skill-hub routes', () => {
       const res = new FakeResponse()
       await routeFor(SKILL_HUB_API.repoImport).handler(fakeReq('POST', SKILL_HUB_API.repoImport, { repo: 'example/repo', paths: ['skills/code-review/SKILL.md'] }), res as never)
       expect(res.status).toBe(200)
-      const body = res.json() as import('./protocol.ts').RepoImportResponse
-      expect(body.imported).toHaveLength(1)
-      expect(body.imported[0]).toMatchObject({ name: 'code-review', origin: 'example/repo' })
+      const created = res.json() as import('./protocol.ts').RepoImportResponse
+      expect(created.jobId).toMatch(/^imp_/)
+      expect(created.total).toBe(1)
+      // 轮询直到完成（后台任务选项2：关面板也继续跑，轮询查进度）
+      let prog: import('./protocol.ts').RepoImportProgressResponse | undefined
+      for (let i = 0; i < 20; i++) {
+        await new Promise((r) => setTimeout(r, 50))
+        const progRes = new FakeResponse()
+        await routeFor(SKILL_HUB_API.repoImportProgress).handler(fakeReq('GET', `${SKILL_HUB_API.repoImportProgress}?jobId=${created.jobId}`), progRes as never)
+        expect(progRes.status).toBe(200)
+        prog = progRes.json() as import('./protocol.ts').RepoImportProgressResponse
+        if (prog.status !== 'running') break
+      }
+      expect(prog).toBeDefined()
+      expect(prog!.status).toBe('done')
+      expect(prog!.imported).toHaveLength(1)
+      expect(prog!.imported[0]).toMatchObject({ name: 'code-review', origin: 'example/repo' })
       await expect(access(join(home, 'skills', 'code-review', 'SKILL.md'))).resolves.toBeUndefined()
       const sources = await store.listSources()
       expect(sources).toHaveLength(1)