Merge origin/master into worktree/ci-under-minute

2026-07-22 17:15:46 +08:00
parent 11236c46fb 67655e33ef
commit 8739abdbfe
113 changed files with 4054 additions and 689 deletions
@@ -1,6 +1,18 @@
-import { afterEach, describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import { fileURLToPath } from 'node:url'
 import { LspConnection } from '@deepseek-ai/dsh-lsp-local'
+import {
+  signalProcessGroup,
+  signalProcessTree,
+  taskkillProcessTree,
+  waitForTreeExit,
+} from '@deepseek-ai/dsh-lsp-local/src/connection.ts'
+import type {
+  ConnectionWriter,
+  ProcessSignalRunner,
+  ProcessTreeOperations,
+  TaskkillRunner,
+} from '@deepseek-ai/dsh-lsp-local/src/connection.ts'

 const fixtureServer = fileURLToPath(new URL('./fixture-server.ts', import.meta.url))

@@ -53,6 +65,12 @@ describe('LspConnection', () => {
    await expect(conn.request('textDocument/hover', {})).rejects.toThrow(/server refused the request/)
  })

+  it('treats signaling an already-closed child as a teardown race', async () => {
+    const conn = connectScript('')
+    await conn.closed
+    expect(() => { conn.kill() }).not.toThrow()
+  })
+
  it('answers a server workspace/configuration request from static config', async () => {
    const seen: SeenRequest[] = []
    const conn = connect(
@@ -125,7 +143,7 @@ describe('LspConnection', () => {
 })

 /** Spawn a raw connection running an inline node script as the "server". */
-function connectScript(script: string, maxStderrBytes = 100_000): LspConnection {
+function connectScript(script: string, maxStderrBytes = 100_000, writer?: ConnectionWriter): LspConnection {
  const conn = new LspConnection({
    command: process.execPath,
    args: ['-e', script],
@@ -134,7 +152,7 @@ function connectScript(script: string, maxStderrBytes = 100_000): LspConnection
    maxMessageBytes: 16_000_000,
    maxStderrBytes,
    configuration: null,
-  }, () => Promise.resolve(null))
+  }, () => Promise.resolve(null), writer)
  open.push(conn)
  return conn
 }
@@ -209,13 +227,13 @@ describe('LspConnection edge behavior', () => {
    await expect(conn.request('initialize', {})).rejects.toThrow(/exited|closed/)
  })

-  it('rejects a pending request when child stdin closes but the process stays alive', async () => {
-    const conn = connectScript('require("node:fs").closeSync(0); process.stderr.write("stdin closed"); setInterval(()=>{}, 1000)')
-    await waitFor(() => conn.stderrTail === 'stdin closed')
-    const timeout = new Promise<never>((_resolve, reject) => {
-      setTimeout(() => { reject(new Error('request timed out')) }, 1000)
-    })
-    await expect(Promise.race([conn.request('initialize', {}), timeout])).rejects.not.toThrow(/timed out/)
+  it('rejects a pending request when child stdin fails but the process stays alive', async () => {
+    const failure = new Error('fixture stdin failure')
+    const writer: ConnectionWriter = (_stdin, _message, done) => {
+      queueMicrotask(() => { done(failure) })
+    }
+    const conn = connectScript('setInterval(()=>{}, 1000)', 100_000, writer)
+    await expect(conn.request('initialize', {})).rejects.toThrow(/fixture stdin failure/)
  })

  it('ignores a frame that is neither a valid request nor a numeric-id response', async () => {
@@ -230,6 +248,72 @@ describe('LspConnection edge behavior', () => {
  })
 })

+describe('process-tree signaling', () => {
+  it('forwards POSIX process-group signals through the host runner', () => {
+    const run: ProcessSignalRunner = vi.fn(() => true)
+    signalProcessGroup(-42, 'SIGKILL', run)
+    expect(run).toHaveBeenCalledWith(-42, 'SIGKILL')
+  })
+
+  it('waits for tree exit and stops when its bound aborts', async () => {
+    const isAlive = vi.fn()
+      .mockReturnValueOnce(true)
+      .mockReturnValue(false)
+    const yieldNow = vi.fn(() => Promise.resolve())
+    await expect(waitForTreeExit(isAlive, undefined, yieldNow)).resolves.toBe(true)
+    expect(yieldNow).toHaveBeenCalledOnce()
+
+    const controller = new AbortController()
+    controller.abort()
+    await expect(waitForTreeExit(() => true, controller.signal, yieldNow)).resolves.toBe(false)
+  })
+
+  it('uses taskkill for a Windows tree and a negative pid for a POSIX group', () => {
+    const operations = fakeProcessTreeOperations()
+    signalProcessTree('win32', 42, 'SIGTERM', operations)
+    expect(operations.taskkill).toHaveBeenCalledWith(42)
+    expect(operations.signal).not.toHaveBeenCalled()
+
+    signalProcessTree('linux', 42, 'SIGKILL', operations)
+    expect(operations.signal).toHaveBeenCalledWith(-42, 'SIGKILL')
+  })
+
+  it('surfaces a Windows taskkill failure without downgrading to the direct child', () => {
+    const fallback = fakeProcessTreeOperations()
+    vi.mocked(fallback.taskkill).mockImplementation(() => { throw new Error('taskkill unavailable') })
+    expect(() => { signalProcessTree('win32', 42, 'SIGTERM', fallback) }).toThrow(/taskkill unavailable/)
+    expect(fallback.killChild).not.toHaveBeenCalled()
+  })
+
+  it('tolerates a POSIX tree-signaling race after the direct child is already gone', () => {
+    const posixGone = fakeProcessTreeOperations()
+    vi.mocked(posixGone.signal).mockImplementation(() => { throw new Error('group gone') })
+    vi.mocked(posixGone.killChild).mockImplementation(() => { throw new Error('child gone') })
+    expect(() => { signalProcessTree('linux', 42, 'SIGKILL', posixGone) }).not.toThrow()
+  })
+
+  it('runs taskkill for the full tree, accepts an absent tree, and rejects command failures', () => {
+    const success: TaskkillRunner = vi.fn(() => ({ status: 0 }))
+    taskkillProcessTree(42, success)
+    expect(success).toHaveBeenCalledWith('taskkill', ['/PID', '42', '/T', '/F'], { stdio: 'ignore' })
+
+    expect(() => { taskkillProcessTree(42, () => ({ status: 128 })) }).not.toThrow()
+
+    const spawnFailure = new Error('cannot spawn taskkill')
+    expect(() => { taskkillProcessTree(42, () => ({ status: null, error: spawnFailure })) }).toThrow(spawnFailure)
+    expect(() => { taskkillProcessTree(42, () => ({ status: 1 })) }).toThrow(/status 1/)
+  })
+})
+
+/** Create observable process-tree operations without touching host processes. */
+function fakeProcessTreeOperations(): ProcessTreeOperations {
+  return {
+    signal: vi.fn(),
+    killChild: vi.fn(),
+    taskkill: vi.fn(),
+  }
+}
+
 /** Poll a predicate until it holds or a deadline elapses. */
 async function waitFor(predicate: () => boolean, timeoutMs = 3000): Promise<void> {
  const start = Date.now()
@@ -16,8 +16,6 @@
 * - LSP_FAKE_OPEN_MARKER: appends each didOpen document text as one JSON line to this path.
 * - LSP_FAKE_INITIALIZED_MARKER: records when the initialized notification is received.
 * - LSP_FAKE_PAUSE_STDIN_AFTER_INITIALIZED: "1" stops consuming stdin after initialized.
- * - LSP_FAKE_CLOSE_STDIN_AFTER_INITIALIZED: "1" closes fd 0 after the initialized notification.
- * - LSP_FAKE_CLOSE_STDIN_AFTER_REPLY: "1" closes fd 0 before sending the first query response.
 * - LSP_FAKE_EXIT_DELAY_MS / LSP_FAKE_EXIT_MARKER: delay protocol exit and record exit/termination.
 * - LSP_FAKE_NO_SHUTDOWN: "1" ignores the shutdown request (forces kill escalation).
 * - LSP_FAKE_ON_OPEN: server→client request to emit when a didOpen arrives, one of
@@ -28,7 +26,7 @@
 * Run: node fixture-server.ts (Node's erasable TypeScript syntax support).
 */

-import { appendFileSync, closeSync } from 'node:fs'
+import { appendFileSync } from 'node:fs'

 const enc = process.env.LSP_FAKE_ENCODING ?? 'utf-16'
 const sync: unknown = process.env.LSP_FAKE_SYNC !== undefined ? JSON.parse(process.env.LSP_FAKE_SYNC) : 1
@@ -40,8 +38,6 @@ const replyDelayMs = Number(process.env.LSP_FAKE_REPLY_DELAY_MS ?? 0)
 const openMarker = process.env.LSP_FAKE_OPEN_MARKER
 const initializedMarker = process.env.LSP_FAKE_INITIALIZED_MARKER
 const pauseStdinAfterInitialized = process.env.LSP_FAKE_PAUSE_STDIN_AFTER_INITIALIZED === '1'
-const closeStdinAfterInitialized = process.env.LSP_FAKE_CLOSE_STDIN_AFTER_INITIALIZED === '1'
-const closeStdinAfterReply = process.env.LSP_FAKE_CLOSE_STDIN_AFTER_REPLY === '1'
 const exitDelayMs = Number(process.env.LSP_FAKE_EXIT_DELAY_MS ?? 0)
 const exitMarker = process.env.LSP_FAKE_EXIT_MARKER
 const noShutdown = process.env.LSP_FAKE_NO_SHUTDOWN === '1'
@@ -146,14 +142,12 @@ function handle(message: { id?: number; method?: string; params?: unknown; resul
  if (method === 'initialized') {
    if (initializedMarker !== undefined) appendFileSync(initializedMarker, 'INITIALIZED\n')
    if (pauseStdinAfterInitialized) process.stdin.pause()
-    if (closeStdinAfterInitialized) closeSync(0)
    return
  }
  if (method === 'textDocument/didClose') return
  if (method?.startsWith('textDocument/')) {
    if (hang) return
    const reply = (): void => {
-      if (closeStdinAfterReply) closeSync(0)
      if (errorReply) {
        send({ id, error: { code: -32000, message: 'server refused the request' } })
      } else {
@@ -202,6 +196,6 @@ function send(message: Record<string, unknown>): void {

 // Keep the event loop alive.
 process.stdin.resume()
-if (pauseStdinAfterInitialized || closeStdinAfterInitialized || closeStdinAfterReply) {
+if (pauseStdinAfterInitialized) {
  setInterval(() => {}, 1000)
 }
@@ -92,7 +92,8 @@ describe('readHostSource', () => {
    await expect(readHostSource('dir', ws, BIG)).rejects.toThrow(/not a regular file/)
  })

-  it('rejects a FIFO with no writer without blocking in open', async () => {
+  // Windows has no filesystem FIFO; the directory case above pins non-regular rejection there.
+  it.skipIf(process.platform === 'win32')('rejects a FIFO with no writer without blocking in open', async () => {
    const fifo = join(ws, 'pipe.ts')
    await execFileAsync('mkfifo', [fifo])
    using d = deadline(undefined, 1000, 'FIFO_READ_TIMEOUT')
@@ -1,9 +1,12 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { mkdtemp, mkdir, readFile, rm, writeFile, realpath } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { pathToFileURL, fileURLToPath } from 'node:url'
 import { LspInstance, readHostSource } from '@deepseek-ai/dsh-lsp-local'
+import { encodeMessage } from '@deepseek-ai/dsh-lsp-local'
+import type { ConnectionWriter } from '@deepseek-ai/dsh-lsp-local/src/connection.ts'
+import { escalateProcessTree } from '@deepseek-ai/dsh-lsp-local/src/instance.ts'
 import type { InstanceSpec } from '@deepseek-ai/dsh-lsp-local/src/instance.ts'
 import type { LspProviderQuery, LspQueryResult } from '@deepseek-ai/dsh-lsp'

@@ -26,7 +29,11 @@ afterEach(async () => {
  await rm(root, { recursive: true, force: true })
 })

-function makeInstance(env: Record<string, string> = {}, overrides: Partial<InstanceSpec> = {}): LspInstance {
+function makeInstance(
+  env: Record<string, string> = {},
+  overrides: Partial<InstanceSpec> = {},
+  writer?: ConnectionWriter,
+): LspInstance {
  const instance = new LspInstance({
    command: process.execPath,
    args: [fixtureServer],
@@ -39,7 +46,7 @@ function makeInstance(env: Record<string, string> = {}, overrides: Partial<Insta
    shutdownTimeoutMs: 200,
    killGraceMs: 200,
    ...overrides,
-  })
+  }, writer)
  live.push(instance)
  return instance
 }
@@ -201,17 +208,25 @@ describe('LspInstance query and abort', () => {
  })

  it('terminates when stdin fails during the didOpen write', async () => {
-    // Closing stdin after initialized makes a large didOpen fail before `opened` can arm didClose;
-    // the instance must still become dead so its provider can replace it.
-    await writeFile(join(ws, 'a.ts'), 'x'.repeat(2_000_000))
-    const instance = makeInstance({ LSP_FAKE_CLOSE_STDIN_AFTER_INITIALIZED: '1' }, {
+    const instance = makeInstance({}, {
      shutdownTimeoutMs: 100,
      killGraceMs: 100,
-    })
+    }, failingWriter('textDocument/didOpen'))
    await expect(run(instance, 'goToDefinition')).rejects.toThrow()
    expect(instance.dead).toBe(true)
  })

+  it('awaits process exit before rejecting a request write failure', async () => {
+    const instance = makeInstance({}, {
+      shutdownTimeoutMs: 100,
+      killGraceMs: 100,
+    }, failingWriter('textDocument/definition'))
+    // The pid is observed only to prove the owned subprocess reached quiescence before rejection.
+    const pid = (instance as unknown as { connection: { pid: number } }).connection.pid
+    await expect(run(instance, 'goToDefinition')).rejects.toThrow(/fixture textDocument\/definition failure/)
+    expect(processAlive(pid)).toBe(false)
+  })
+
  it('rejects when the server lacks the operation capability', async () => {
    const instance = makeInstance({ LSP_FAKE_CAPS: JSON.stringify({ definitionProvider: false }), LSP_FAKE_DEF: 'null' })
    await expect(run(instance, 'goToDefinition')).rejects.toThrow(/does not support goToDefinition/)
@@ -228,8 +243,7 @@ describe('LspInstance query and abort', () => {
  it('keeps a settled result but awaits teardown when didClose cannot be written', async () => {
    const instance = makeInstance({
      LSP_FAKE_DEF: 'null',
-      LSP_FAKE_CLOSE_STDIN_AFTER_REPLY: '1',
-    }, { shutdownTimeoutMs: 100, killGraceMs: 100 })
+    }, { shutdownTimeoutMs: 100, killGraceMs: 100 }, failingWriter('textDocument/didClose'))
    await expect(run(instance, 'goToDefinition')).resolves.toEqual({
      kind: 'locations',
      locations: [],
@@ -240,6 +254,14 @@ describe('LspInstance query and abort', () => {
 })

 describe('LspInstance disposal', () => {
+  it('escalates only when the process tree survives its grace period', () => {
+    const forceKill = vi.fn()
+    escalateProcessTree(false, forceKill)
+    expect(forceKill).toHaveBeenCalledOnce()
+    escalateProcessTree(true, forceKill)
+    expect(forceKill).toHaveBeenCalledOnce()
+  })
+
  it('lets a server finish protocol exit before signal escalation', async () => {
    const marker = join(root, 'graceful-exit.log')
    const instance = makeInstance({
@@ -281,7 +303,7 @@ describe('LspInstance disposal', () => {
    await expect(instance.dispose()).resolves.toBeUndefined()
  })

-  it('awaits a surviving process-group helper on every concurrent dispose', async () => {
+  it('awaits a surviving process-tree helper on every concurrent dispose', async () => {
    const marker = join(root, 'helper.pid')
    const helper = 'process.on("SIGTERM",()=>{});setInterval(()=>{},1000);'
    const script = 'const{spawn}=require("node:child_process");const{writeFileSync}=require("node:fs");'
@@ -298,6 +320,7 @@ describe('LspInstance disposal', () => {
      await first
    } finally {
      if (processAlive(helperPid)) process.kill(helperPid, 'SIGKILL')
+      await waitForProcessExit(helperPid)
    }
  })

@@ -322,6 +345,26 @@ function processAlive(pid: number): boolean {
  }
 }

+/** Wait until a process id disappears so temporary-workspace cleanup cannot race handle release. */
+async function waitForProcessExit(pid: number, timeoutMs = 3_000): Promise<void> {
+  const started = Date.now()
+  while (processAlive(pid)) {
+    if (Date.now() - started > timeoutMs) throw new Error(`process ${pid} did not exit`)
+    await new Promise<void>(resolve => setTimeout(resolve, 10))
+  }
+}
+
+/** Write normally except for one method whose callback receives a deterministic transport error. */
+function failingWriter(method: string): ConnectionWriter {
+  return (stdin, message, done) => {
+    if ((message as { method?: unknown }).method === method) {
+      queueMicrotask(() => { done(new Error(`fixture ${method} failure`)) })
+      return
+    }
+    stdin.write(encodeMessage(message), done)
+  }
+}
+
 /** Wait until a fixture marker exists, bounded so a broken handshake cannot hang the test. */
 async function waitForFile(path: string, timeoutMs = 3000): Promise<void> {
  const started = Date.now()
@@ -137,9 +137,15 @@ describe('lsp-local end to end over a fake server', () => {
    await ctx.fiber.dispose()
  })

-  it('rejects a non-utf-16 position encoding at initialize', async () => {
-    const ctx = await mount({ LSP_FAKE_ENCODING: 'utf-8', LSP_FAKE_DEF: 'null' })
+  it('rejects a non-utf-16 position encoding at initialize without retrying', async () => {
+    const marker = join(root, 'initialize-rejection-exit.log')
+    const ctx = await mount({
+      LSP_FAKE_ENCODING: 'utf-8',
+      LSP_FAKE_DEF: 'null',
+      LSP_FAKE_EXIT_MARKER: marker,
+    })
    await expect(ctx.lsp.query(query('goToDefinition'))).rejects.toThrow(/unsupported position encoding/)
+    expect(await readFile(marker, 'utf8')).toBe('EXIT\nCLEAN\n')
    await ctx.fiber.dispose()
  })

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import { chmod, mkdtemp, mkdir, rm, writeFile, realpath } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { delimiter, join } from 'node:path'
 import { Context } from 'cordis'
 import Lsp, { type LspQueryRequest } from '@deepseek-ai/dsh-lsp'
 import * as LspLocal from '@deepseek-ai/dsh-lsp-local'
@@ -57,7 +57,7 @@ describe('lsp-local provider resolution', () => {
    await expect(ctx.plugin(LspLocal, config('nope', {
      command: 'fake-lsp',
      args: [],
-      env: { PATH: `::${join(root, 'empty')}` },
+      env: { PATH: `${delimiter}${delimiter}${join(root, 'empty')}` },
      extensionToLanguage: { '.ts': 'typescript' },
    }))).rejects.toThrow(/was not found on PATH/)
    await ctx.fiber.dispose()
@@ -116,7 +116,8 @@ describe('lsp-local provider resolution', () => {
    await ctx.fiber.dispose()
  })

-  it('rejects an absolute command that is not executable at load', async () => {
+  // Node's X_OK probe is an existence check on Windows, which has no executable mode bit.
+  it.skipIf(process.platform === 'win32')('rejects an absolute command that is not executable at load', async () => {
    const notExe = join(root, 'not-exe.txt')
    await writeFile(notExe, 'plain text, not executable')
    const ctx = new Context()