@jetcrab/pi-desk 1.1.18-dev → 1.1.21

package/src/server/l4_foundation/file/l4-work-session-project-file.ts

@@ -1,47 +1,31 @@
 import 'server-only'
 
-import { execFile, spawn } from 'node:child_process'
+import { spawn } from 'node:child_process'
 import { open, readFile, readdir, realpath, stat } from 'node:fs/promises'
-import { basename, dirname, isAbsolute, relative, resolve, sep } from 'node:path'
-import { promisify } from 'node:util'
+import { dirname, isAbsolute, resolve } from 'node:path'
 import sharp from 'sharp'
 import {
   L4_PROJECT_FILE_LIST_MAX_ENTRIES,
-  L4_PROJECT_FILE_SEARCH_MAX_RESULTS,
   L4_PROJECT_IMAGE_FILE_MAX_BYTES,
   L4_PROJECT_IMAGE_MAX_PIXELS,
   L4_PROJECT_TEXT_FILE_MAX_BYTES,
   type L4ProjectFileEntry,
   type L4ProjectFileList,
-  type L4ProjectFileSearch,
   type L4ProjectFileContent,
   type L4ProjectFileImageMimeType,
   type L4ProjectFileImagePreviewMode
 } from '@common/l4_foundation/file/l4-project-file-contract'
-import { listL4WorkSessionGitRepositoryRoots } from '@server/l4_foundation/git/l4-work-session-git'
+import { isL4PathInsideRoot as isInsideRoot } from './l4-file-path'
 import {
-  getL4FileSystemKey as fileSystemKey,
-  isL4PathInsideRoot as isInsideRoot
-} from './l4-file-path'
-
-const execFileAsync = promisify(execFile)
-const SEARCH_CACHE_TTL_MS = 30_000
-const SEARCH_CACHE_MAX_CWDS = 20
-const SEARCH_INDEX_MAX_FILES = 50_000
+  IGNORED_NAMES,
+  invalidateSearchIndex,
+  isSupportedProtocolName
+} from './l4-project-file-index'
+
 const IMAGE_COMPRESSION_MIN_BYTES = 512 * 1024
 const IMAGE_COMPRESSION_MAX_WIDTH = 2560
 const IMAGE_COMPRESSION_MIN_SAVING_RATIO = 0.15
 
-const IGNORED_NAMES = new Set([
-  '.git',
-  'node_modules',
-  '.next',
-  'dist',
-  'build',
-  'coverage',
-  '.turbo'
-])
-
 export type L4WorkSessionProjectFileErrorKind =
   | 'not-found'
   | 'not-directory'
@@ -71,15 +55,8 @@ export function getL4WorkSessionProjectFileErrorKind(
 
 export type L4WorkSessionProjectFileEntry = L4ProjectFileEntry
 export type L4WorkSessionProjectFileList = L4ProjectFileList
-export type L4WorkSessionProjectFileSearch = L4ProjectFileSearch
 export type L4WorkSessionProjectFileGet = L4ProjectFileContent
 
-interface SearchIndexCacheEntry {
-  files: string[]
-  truncated: boolean
-  expiresAt: number
-}
-
 interface ProjectFileRevealTarget {
   target: string
   directory: string
@@ -88,21 +65,6 @@ interface ProjectFileRevealTarget {
 
 type ProjectFileRevealRunner = (command: string, args: string[]) => Promise<void>
 
-const searchIndexCache = new Map<string, SearchIndexCacheEntry>()
-const pendingSearchIndexes = new Map<string, Promise<SearchIndexCacheEntry>>()
-
-function joinProtocolPath(parent: string, name: string): string {
-  return parent ? `${parent}/${name}` : name
-}
-
-function isSupportedProtocolName(name: string): boolean {
-  return name.length > 0 && !name.includes('/') && !name.includes('\\') && !name.includes('\0')
-}
-
-function pathContainsIgnoredSegment(path: string): boolean {
-  return path.split('/').some((segment) => IGNORED_NAMES.has(segment))
-}
-
 async function resolveProjectRoot(cwd: string): Promise<string> {
   try {
     const root = await realpath(cwd)
@@ -249,12 +211,6 @@ async function runProjectFileRevealCommand(command: string, args: string[]): Pro
   })
 }
 
-function invalidateSearchIndex(root: string): void {
-  const key = fileSystemKey(root)
-  searchIndexCache.delete(key)
-  pendingSearchIndexes.delete(key)
-}
-
 export async function listL4WorkSessionProjectFiles(
   cwd: string,
   protocolPath: string
@@ -318,286 +274,6 @@ export async function listL4WorkSessionProjectFiles(
   }
 }
 
-const GIT_SEARCH_OPTIONS = {
-  timeout: 10_000,
-  maxBuffer: 64 * 1024 * 1024,
-  env: { ...process.env, LC_ALL: 'C', GIT_OPTIONAL_LOCKS: '0' }
-}
-
-async function listFilesWithContainingGit(
-  root: string
-): Promise<{ files: string[]; truncated: boolean } | null> {
-  try {
-    const { stdout: topLevelOutput } = await execFileAsync(
-      'git',
-      ['-C', root, 'rev-parse', '--show-toplevel'],
-      GIT_SEARCH_OPTIONS
-    )
-    const topLevel = await realpath(topLevelOutput.trim())
-    const prefix = relative(topLevel, root).split(sep).join('/')
-    const { stdout } = await execFileAsync(
-      'git',
-      [
-        '-C',
-        topLevel,
-        'ls-files',
-        '--full-name',
-        '--cached',
-        '--others',
-        '--exclude-standard',
-        '-z',
-        '--',
-        prefix || '.'
-      ],
-      GIT_SEARCH_OPTIONS
-    )
-    const prefixWithSlash = prefix ? `${prefix}/` : ''
-    const all = stdout
-      .split('\0')
-      .flatMap((path) => {
-        if (!path) return []
-        const projectPath = prefixWithSlash
-          ? path.startsWith(prefixWithSlash)
-            ? path.slice(prefixWithSlash.length)
-            : ''
-          : path
-        return projectPath ? [projectPath] : []
-      })
-      .filter(
-        (path) =>
-          isSupportedProtocolName(basename(path)) &&
-          !path.includes('\\') &&
-          !pathContainsIgnoredSegment(path)
-      )
-    return {
-      files: all.slice(0, SEARCH_INDEX_MAX_FILES),
-      truncated: all.length > SEARCH_INDEX_MAX_FILES
-    }
-  } catch {
-    return null
-  }
-}
-
-function isPathInsideRepository(path: string, repositoryRoot: string): boolean {
-  return path === repositoryRoot || path.startsWith(`${repositoryRoot}/`)
-}
-
-async function listFilesInRepository(
-  projectRoot: string,
-  repositoryRoot: string,
-  nestedRepositoryRoots: readonly string[]
-): Promise<{ files: string[]; truncated: boolean } | null> {
-  const absoluteRoot = repositoryRoot
-    ? resolve(projectRoot, ...repositoryRoot.split('/'))
-    : projectRoot
-  try {
-    const { stdout } = await execFileAsync(
-      'git',
-      [
-        '-C',
-        absoluteRoot,
-        'ls-files',
-        '--full-name',
-        '--cached',
-        '--others',
-        '--exclude-standard',
-        '-z'
-      ],
-      GIT_SEARCH_OPTIONS
-    )
-    const files = stdout.split('\0').flatMap((path) => {
-      if (!path || path.includes('\\') || pathContainsIgnoredSegment(path)) return []
-      const projectPath = joinProtocolPath(repositoryRoot, path)
-      if (
-        nestedRepositoryRoots.some((nestedRoot) => isPathInsideRepository(projectPath, nestedRoot))
-      ) {
-        return []
-      }
-      return isSupportedProtocolName(basename(projectPath)) ? [projectPath] : []
-    })
-    return {
-      files: files.slice(0, SEARCH_INDEX_MAX_FILES),
-      truncated: files.length > SEARCH_INDEX_MAX_FILES
-    }
-  } catch {
-    return null
-  }
-}
-
-async function listFilesWithWalk(
-  root: string,
-  excludedRepositoryRoots: readonly string[] = []
-): Promise<{ files: string[]; truncated: boolean }> {
-  const files: string[] = []
-  const queue: Array<{ absolute: string; relative: string }> = [{ absolute: root, relative: '' }]
-  let queueIndex = 0
-
-  while (queueIndex < queue.length) {
-    const current = queue[queueIndex]!
-    queueIndex += 1
-    let dirents
-    try {
-      dirents = await readdir(current.absolute, { withFileTypes: true })
-    } catch {
-      continue
-    }
-
-    for (const entry of dirents) {
-      if (IGNORED_NAMES.has(entry.name) || !isSupportedProtocolName(entry.name)) continue
-      const childRelative = joinProtocolPath(current.relative, entry.name)
-      if (entry.isDirectory()) {
-        if (excludedRepositoryRoots.includes(childRelative)) continue
-        queue.push({ absolute: resolve(current.absolute, entry.name), relative: childRelative })
-        continue
-      }
-      if (!entry.isFile()) continue
-      files.push(childRelative)
-      if (files.length >= SEARCH_INDEX_MAX_FILES) return { files, truncated: true }
-    }
-  }
-
-  return { files, truncated: false }
-}
-
-async function listFilesWithRepositoryRoots(
-  projectRoot: string,
-  repositoryRoots: readonly string[]
-): Promise<{ files: string[]; truncated: boolean }> {
-  const files = new Set<string>()
-  let truncated = false
-  const hasProjectRootRepository = repositoryRoots.includes('')
-
-  if (!hasProjectRootRepository) {
-    const workspaceFiles = await listFilesWithWalk(projectRoot, repositoryRoots.filter(Boolean))
-    for (const path of workspaceFiles.files) files.add(path)
-    truncated ||= workspaceFiles.truncated
-  }
-
-  for (const repositoryRoot of repositoryRoots) {
-    const nestedRoots = repositoryRoots.filter(
-      (candidate) =>
-        candidate !== repositoryRoot &&
-        (repositoryRoot === '' || candidate.startsWith(`${repositoryRoot}/`))
-    )
-    let listing = await listFilesInRepository(projectRoot, repositoryRoot, nestedRoots)
-    if (!listing) {
-      const absoluteRoot = repositoryRoot
-        ? resolve(projectRoot, ...repositoryRoot.split('/'))
-        : projectRoot
-      const nestedRelativeRoots = nestedRoots.map((root) =>
-        repositoryRoot ? root.slice(repositoryRoot.length + 1) : root
-      )
-      const fallback = await listFilesWithWalk(absoluteRoot, nestedRelativeRoots)
-      listing = {
-        files: fallback.files.map((path) => joinProtocolPath(repositoryRoot, path)),
-        truncated: fallback.truncated
-      }
-    }
-    for (const path of listing.files) {
-      files.add(path)
-      if (files.size >= SEARCH_INDEX_MAX_FILES) {
-        return { files: [...files], truncated: true }
-      }
-    }
-    truncated ||= listing.truncated
-  }
-
-  return { files: [...files], truncated }
-}
-
-async function getSearchIndex(root: string): Promise<SearchIndexCacheEntry> {
-  const key = fileSystemKey(root)
-  const now = Date.now()
-  const cached = searchIndexCache.get(key)
-  if (cached && cached.expiresAt > now) return cached
-
-  const active = pendingSearchIndexes.get(key)
-  if (active) return active
-
-  const load: Promise<SearchIndexCacheEntry> = Promise.resolve().then(async () => {
-    const repositoryRoots = await listL4WorkSessionGitRepositoryRoots(root)
-    const listing =
-      repositoryRoots.length > 0
-        ? await listFilesWithRepositoryRoots(root, repositoryRoots)
-        : ((await listFilesWithContainingGit(root)) ?? (await listFilesWithWalk(root)))
-    const next: SearchIndexCacheEntry = {
-      ...listing,
-      expiresAt: now + SEARCH_CACHE_TTL_MS
-    }
-    if (pendingSearchIndexes.get(key) === load) {
-      for (const [cacheKey, entry] of searchIndexCache) {
-        if (entry.expiresAt <= Date.now()) searchIndexCache.delete(cacheKey)
-      }
-      while (searchIndexCache.size >= SEARCH_CACHE_MAX_CWDS) {
-        const oldestKey = searchIndexCache.keys().next().value as string
-        searchIndexCache.delete(oldestKey)
-      }
-      searchIndexCache.set(key, next)
-    }
-    return next
-  })
-  pendingSearchIndexes.set(key, load)
-  try {
-    return await load
-  } finally {
-    if (pendingSearchIndexes.get(key) === load) pendingSearchIndexes.delete(key)
-  }
-}
-
-function subsequenceGapScore(value: string, query: string): number | null {
-  let queryIndex = 0
-  let firstIndex = -1
-  let previousIndex = -1
-  let gaps = 0
-
-  for (
-    let valueIndex = 0;
-    valueIndex < value.length && queryIndex < query.length;
-    valueIndex += 1
-  ) {
-    if (value[valueIndex] !== query[queryIndex]) continue
-    if (firstIndex < 0) firstIndex = valueIndex
-    if (previousIndex >= 0) gaps += valueIndex - previousIndex - 1
-    previousIndex = valueIndex
-    queryIndex += 1
-  }
-
-  return queryIndex === query.length ? firstIndex * 4 + gaps : null
-}
-
-function searchScore(path: string, query: string): number | null {
-  const normalizedPath = path.toLocaleLowerCase()
-  const name = basename(normalizedPath)
-  if (name === query) return 0
-  if (name.startsWith(query)) return 100 + name.length - query.length
-  const nameIndex = name.indexOf(query)
-  if (nameIndex >= 0) return 1_000 + nameIndex * 4 + name.length
-  const pathIndex = normalizedPath.indexOf(query)
-  if (pathIndex >= 0) return 10_000 + pathIndex * 4 + normalizedPath.length
-  const fuzzy = subsequenceGapScore(normalizedPath, query)
-  return fuzzy === null ? null : 100_000 + fuzzy + normalizedPath.length
-}
-
-export async function searchL4WorkSessionProjectFiles(
-  cwd: string,
-  query: string
-): Promise<L4WorkSessionProjectFileSearch> {
-  const root = await resolveProjectRoot(cwd)
-  const index = await getSearchIndex(root)
-  const normalizedQuery = query.toLocaleLowerCase()
-  const matches = index.files
-    .flatMap((path) => {
-      const score = searchScore(path, normalizedQuery)
-      return score === null ? [] : [{ path, score }]
-    })
-    .sort((left, right) => left.score - right.score || left.path.localeCompare(right.path))
-
-  return {
-    matches: matches.slice(0, L4_PROJECT_FILE_SEARCH_MAX_RESULTS).map((match) => match.path),
-    truncated: index.truncated || matches.length > L4_PROJECT_FILE_SEARCH_MAX_RESULTS
-  }
-}
-
 export async function revealL4WorkSessionProjectFile(
   cwd: string,
   protocolPath: string,

package/src/server/l4_foundation/model-settings/l4-model-settings-store.ts

@@ -624,7 +624,7 @@ async function assertConnectionCredentials(
 }
 
 async function prepareProjectDefaultChanges(
-  current: JsonRecord,
+  removed: Set<string>,
   candidate: JsonRecord,
   input: L4ModelSettingsReplaceInput,
   runtime: ModelRuntime,
@@ -633,16 +633,14 @@ async function prepareProjectDefaultChanges(
   projectDefaults: L4ModelSettingsPreview['projectDefaults']
   files: Array<{ path: string; value: JsonRecord }>
 }> {
-  const previousKeys = collectedModelKeys(current)
   const nextKeys = collectedModelKeys(candidate)
-  const removed = new Set([...previousKeys].filter((key) => !nextKeys.has(key)))
   const replacements = new Map<string, L4ModelOption>()
   for (const { from, to } of input.modelReplacements ?? []) {
     const fromKey = collectedModelKey(from.provider, from.modelId)
     const toKey = collectedModelKey(to.provider, to.modelId)
     if (fromKey === toKey) throw new Error('模型替换来源和目标不能相同')
     if (replacements.has(fromKey)) throw new Error('模型替换来源不能重复')
-    if (!previousKeys.has(fromKey) || !removed.has(fromKey)) {
+    if (!removed.has(fromKey)) {
       throw new Error(`替换来源 ${from.provider}/${from.modelId} 必须是本次移除的已收录模型`)
     }
     const target = models.find(
@@ -658,13 +656,6 @@ async function prepareProjectDefaultChanges(
     files: Array<{ path: string; value: JsonRecord }>
   } = { projectDefaults: [], files: [] }
   if (!removed.size) return result
-  for (const preset of normalizePresets(candidate)) {
-    if (removed.has(collectedModelKey(preset.provider, preset.modelId))) {
-      throw new Error(
-        `模型 ${preset.provider}/${preset.modelId} 仍被常用组合引用，请先移除对应组合`
-      )
-    }
-  }
   // 仅在移除模型时检查已知项目，不扫描文件系统寻找任意项目配置。
   const projects = await listL4PiDirectorySummaries(true)
   for (const { cwd } of projects) {
@@ -681,11 +672,20 @@ async function prepareProjectDefaultChanges(
     const provider = merged.getDefaultProvider()
     const modelId = merged.getDefaultModel()
     if (!provider || !modelId || !removed.has(collectedModelKey(provider, modelId))) continue
+    const from: L4ModelSelection = {
+      provider,
+      modelId,
+      thinkingLevel: merged.getDefaultThinkingLevel() ?? 'off'
+    }
     const target = replacements.get(collectedModelKey(provider, modelId))
     if (!target) {
-      throw new Error(
-        `项目“${cwd}”仍将 ${provider}/${modelId} 设为默认模型，请先在“项目默认”中调整`
-      )
+      const value = { ...settings }
+      delete value.defaultProvider
+      delete value.defaultModel
+      delete value.defaultThinkingLevel
+      result.projectDefaults.push({ cwd, from, to: null })
+      result.files.push({ path, value })
+      continue
     }
     const projectModels = await availableModelOptions(runtime, cwd, candidate)
     if (
@@ -695,11 +695,6 @@ async function prepareProjectDefaultChanges(
     ) {
       throw new Error(`替换目标 ${target.provider}/${target.modelId} 在项目“${cwd}”中不可用`)
     }
-    const from: L4ModelSelection = {
-      provider,
-      modelId,
-      thinkingLevel: merged.getDefaultThinkingLevel() ?? 'off'
-    }
     const thinkingLevel = target.thinkingLevels.includes(from.thinkingLevel)
       ? from.thinkingLevel
       : target.thinkingLevels[0]
@@ -785,11 +780,25 @@ async function prepareModelSettings(input: L4ModelSettingsReplaceInput): Promise
         : await ModelRuntime.create({ modelsPath: null, allowModelNetwork: false })
     candidate = mergeModelsRoot(current, input, currentRuntime, defaults)
   }
+  const nextKeys = collectedModelKeys(candidate)
+  const removed = new Set([...collectedModelKeys(current)].filter((key) => !nextKeys.has(key)))
+  if (removed.size && Array.isArray(candidate.modelPresets)) {
+    candidate = {
+      ...candidate,
+      modelPresets: candidate.modelPresets.filter(
+        (preset) =>
+          !isRecord(preset) ||
+          typeof preset.provider !== 'string' ||
+          typeof preset.modelId !== 'string' ||
+          !removed.has(collectedModelKey(preset.provider, preset.modelId))
+      )
+    }
+  }
   const runtime = await validateModelsRoot(candidate)
   const models = await availableModelOptions(runtime, undefined, candidate)
   await assertConnectionCredentials(current, candidate, runtime)
   assertPresetsValid(normalizePresets(candidate), models, normalizePresets(current))
-  const result = await prepareProjectDefaultChanges(current, candidate, input, runtime, models)
+  const result = await prepareProjectDefaultChanges(removed, candidate, input, runtime, models)
   result.files.push({ path, value: candidate })
   return result
 }

package/src/server/l4_foundation/model-settings/l4-model-settings-types.ts

@@ -97,7 +97,7 @@ export interface L4ModelReplacement {
 }
 
 export interface L4ModelSettingsPreview {
-  projectDefaults: Array<{ cwd: string; from: L4ModelSelection; to: L4ModelSelection }>
+  projectDefaults: Array<{ cwd: string; from: L4ModelSelection; to: L4ModelSelection | null }>
 }
 
 export type L4ModelSettingsReplaceInput =

package/src/server/l4_foundation/pi/l4-pi-chat-worker.ts

@@ -425,6 +425,24 @@ export class L4PiChatWorker {
       readCapabilities: this.capabilities.rules,
       onInput: (event) =>
         this.validateFinalInput(event.text, event.images, event.streamingBehavior),
+      onMessageEnd: ({ message }) => {
+        if (
+          this.disposed ||
+          !this.oversizedToolCallAbortRequested ||
+          message.role !== 'assistant' ||
+          (message.stopReason !== 'aborted' && message.stopReason !== 'error')
+        ) {
+          return
+        }
+        return {
+          message: {
+            ...message,
+            stopReason: 'error',
+            // Pi 按错误文本识别可重试失败，保留其已支持的重试提示。
+            errorMessage: `工具参数流超过 ${L4_PI_CHAT_MAX_STREAMING_TOOL_ARGUMENT_CHARS} 字符上限，本次响应中的工具均未执行。Please retry your request.`
+          }
+        }
+      },
       onTree: () => this.resetBranchRuntime(),
       onCommand: (args, toolCallId) => {
         const signal = this.commandLifetime.signal
@@ -862,9 +880,8 @@ export class L4PiChatWorker {
     this.nativeUi.cancelAll()
     this.discardAcceptedInputs()
     const session = await this.ensureSession()
-    session.abortRetry()
-    session.abortCompaction()
-    session.agent.abort()
+    this.oversizedToolCallAbortRequested = false
+    await session.abort()
   }
 
   async navigateTree(entryId: string): Promise<boolean> {
@@ -1604,9 +1621,9 @@ export class L4PiChatWorker {
     const oversized = findOversizedStreamingToolCall(message)
     if (!oversized) return false
 
-    if (!this.oversizedToolCallAbortRequested) {
+    if (!this.oversizedToolCallAbortRequested && !this.session?.agent.signal?.aborted) {
       this.oversizedToolCallAbortRequested = true
-      console.warn('[Pi Desk][PiChatWorker] 工具参数流过大，已中止当前 Agent', {
+      console.warn('[Pi Desk][PiChatWorker] 工具参数流过大，已中止当前运行，交由 Pi 重试策略处理', {
         sessionId: this.sessionManager.getSessionId(),
         toolCallId: oversized.toolCallId,
         toolName: oversized.toolName,

package/src/server/l4_foundation/pi/l4-pi-package-maintenance.ts

@@ -81,12 +81,6 @@ export async function runL4PiPackageMaintenance(input: {
         'failed',
         '包维护超过120秒，已停止；结果未确认，请检查配置后手动处理',
         null
-      ),
-    cleanupError: (_output, error) =>
-      new L4PiPackageMaintenanceError(
-        'failed',
-        `维护进程树未确认释放：${error instanceof Error ? error.message : String(error)}`,
-        null
       )
   })
   if (code === 0) return

package/src/server/l4_foundation/pi/l4-pi-plugin-capability-probe.ts

@@ -138,9 +138,7 @@ export async function runL4PiPluginCapabilityProbe(
     env: { PI_DESK_PLUGIN_CAPABILITY_AGENT_DIR: agentDir, PI_DESK_PLUGIN_CAPABILITY_CWD: cwd },
     maxOutputBytes: L4_PI_PLUGIN_CAPABILITY_PROBE_MAX_OUTPUT_BYTES,
     timeoutMs: L4_PI_PLUGIN_CAPABILITY_PROBE_TIMEOUT_MS,
-    timeoutError: () => new Error('插件能力盘点超时'),
-    cleanupError: (output, error) =>
-      new Error(`${output}\n能力盘点进程树清理失败`, { cause: error })
+    timeoutError: () => new Error('插件能力盘点超时')
   })
   if (code !== 0) throw new Error(stderr.trim() || `插件能力盘点进程退出码 ${code ?? 'null'}`)
   const marker = stdout.lastIndexOf(L4_PI_PLUGIN_CAPABILITY_PROBE_RESULT_PREFIX)