feat(cli): launch dsh source through the tsx ESM hook

Node 26.0.0 removed --experimental-transform-types, so the native
source-launch chain cannot start anywhere on that line, and strip-only
mode rejects the vendored syntax (parameter properties, decorators,
runtime enums/namespaces). Switch bin/dsh, the root dsh/demo:tui/
demo:web scripts, and the Code Mode TUI overlay to node --import
tsx/esm: one launch vector across the whole engines range, ~0.4s faster
than the full tsx default (the CJS hook stays off; the graph is
ESM-only).

Delete scripts/tspath-loader.ts and apps/cli/src/tsconfig-paths-loader.ts:
tsx owns both transformation and tsconfig paths projection. Add
dsh-source-launch-smoke to the node-compat gates so the 22.19/26 matrix
executes the real launch vector; no CI job did, which is how the Node 26
breakage shipped silently.

Supersedes the native-TypeScript-source-launch Agent Note (new note
records the profiling evidence and rejected alternatives).
This commit is contained in:
kingwl
2026-07-29 13:15:24 +08:00
parent 6ff2c53661
commit aebf9c863b
18 changed files with 148 additions and 429 deletions

View File

@@ -0,0 +1,36 @@
import { fileURLToPath } from 'node:url'
import { execa } from 'execa'
import { describe, expect, it } from 'vitest'
/**
* Keyless smoke for the SOURCE `dsh` launcher: run `apps/cli/src/bin.ts`
* with the exact production launch vector (`node --import tsx/esm`, the same
* shape as `bin/dsh` and the root `dsh`/`demo:tui`/`demo:web` scripts) and
* assert the piped-stdio TTY refusal. The Node compatibility matrix runs this
* WHOLE file, so a Node release changing module hooks or TypeScript handling
* breaks this gate instead of every developer's `pnpm dsh`; the built-bin
* suite covers the published `lib/` entry, not this source chain.
*/
const repoRoot = fileURLToPath(new URL('../../../', import.meta.url))
const dshSourceBin = 'apps/cli/src/bin.ts'
describe('dsh SOURCE launcher (node --import tsx/esm)', () => {
it('boots the source entry and refuses pipes LOUD (non-zero exit + stderr)', async () => {
const result = await execa(process.execPath, ['--import', 'tsx/esm', dshSourceBin], {
cwd: repoRoot,
input: '',
timeout: 25_000,
killSignal: 'SIGKILL',
reject: false,
})
if (result.timedOut) {
throw new Error(`dsh source launch did not exit within 25s. stdout:\n${result.stdout}\nstderr:\n${result.stderr}`)
}
expect(result.exitCode).not.toBe(0)
expect(result.stderr).toContain('requires stdin and stdout to be interactive TTYs')
expect(result.stderr).toContain('dsh -p')
// The refusal happens before any plugin mounts: stdout stays silent.
expect(result.stdout).toBe('')
}, 30_000)
})

View File

@@ -1,180 +0,0 @@
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
import type { ResolveFnOutput, ResolveHookContext } from 'node:module'
import { tmpdir } from 'node:os'
import { dirname, join } from 'node:path'
import { pathToFileURL } from 'node:url'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { initialize, resolveHook, TsconfigPathsResolver } from '../src/tsconfig-paths-loader.ts'
class ResolverFixture {
readonly root = mkdtempSync(join(tmpdir(), 'dsh-tsconfig-paths-'))
path(relativePath: string): string {
return join(this.root, relativePath)
}
write(relativePath: string, content = 'export {}\n'): string {
const path = this.path(relativePath)
mkdirSync(dirname(path), { recursive: true })
writeFileSync(path, content)
return path
}
writeJson(relativePath: string, value: unknown): string {
return this.write(relativePath, `${JSON.stringify(value)}\n`)
}
createResolver(paths: Record<string, string[]>): TsconfigPathsResolver {
const tsconfigPath = this.writeJson('tsconfig.json', { compilerOptions: { paths } })
return TsconfigPathsResolver.create(tsconfigPath)
}
parentURL(relativePath = 'consumer/src/nested/index.ts'): string {
return pathToFileURL(this.path(relativePath)).href
}
dispose(): void {
rmSync(this.root, { recursive: true, force: true })
}
}
const fixtures: ResolverFixture[] = []
function fixture(): ResolverFixture {
const value = new ResolverFixture()
fixtures.push(value)
return value
}
afterEach(() => {
for (const value of fixtures.splice(0)) value.dispose()
})
describe('TsconfigPathsResolver', () => {
it('orders exact, longer-prefix, and longer-suffix path rules', async () => {
const files = fixture()
files.writeJson('consumer/package.json', {
dependencies: {
'@scope/feature-name': '*',
'@scope/feature-other': '*',
'@scope/plain-suffix': '*',
},
})
files.write('targets/exact.ts')
files.write('targets/prefix/other.ts')
files.write('targets/generic/feature-other.ts')
files.write('targets/suffix/plain.ts')
files.write('targets/generic/plain-suffix.ts')
const resolver = files.createResolver({
'@scope/*': ['./targets/generic/*'],
'@scope/*-suffix': ['./targets/suffix/*'],
'@scope/feature-*': ['./targets/prefix/*'],
'@scope/feature-name': ['./targets/exact.ts'],
})
await expect(resolver.resolve('@scope/feature-name', files.parentURL()))
.resolves.toBe(pathToFileURL(files.path('targets/exact.ts')).href)
await expect(resolver.resolve('@scope/feature-other', files.parentURL()))
.resolves.toBe(pathToFileURL(files.path('targets/prefix/other.ts')).href)
await expect(resolver.resolve('@scope/plain-suffix', files.parentURL()))
.resolves.toBe(pathToFileURL(files.path('targets/suffix/plain.ts')).href)
})
it('resolves only self-references and runtime dependencies from the nearest ancestor manifest', async () => {
const files = fixture()
files.writeJson('consumer/package.json', {
name: 'self-package',
dependencies: { dependency: '*' },
optionalDependencies: { optional: '*' },
peerDependencies: { peer: '*' },
})
for (const name of ['self-package', 'dependency', 'optional', 'peer', 'undeclared']) {
files.write(`targets/${name}.ts`)
}
const resolver = files.createResolver(Object.fromEntries(
['self-package', 'dependency', 'optional', 'peer', 'undeclared']
.map(name => [name, [`./targets/${name}`]]),
))
for (const name of ['self-package', 'dependency', 'optional', 'peer']) {
await expect(resolver.resolve(name, files.parentURL()))
.resolves.toBe(pathToFileURL(files.path(`targets/${name}.ts`)).href)
}
await expect(resolver.resolve('undeclared', files.parentURL())).resolves.toBeUndefined()
})
it('probes native TypeScript extensions and index files but excludes TSX and missing targets', async () => {
const files = fixture()
const names = ['plain-ts', 'module-mts', 'common-cts', 'directory', 'tsx-implicit', 'tsx-explicit', 'missing']
files.writeJson('consumer/package.json', {
dependencies: Object.fromEntries(names.map(name => [name, '*'])),
})
files.write('targets/plain.ts')
files.write('targets/module.mts')
files.write('targets/common.cts')
files.write('targets/directory/index.ts')
files.write('targets/component.tsx')
const resolver = files.createResolver({
'plain-ts': ['./targets/plain'],
'module-mts': ['./targets/module'],
'common-cts': ['./targets/common'],
'directory': ['./targets/directory'],
'tsx-implicit': ['./targets/component'],
'tsx-explicit': ['./targets/component.tsx'],
'missing': ['./targets/missing'],
})
for (const [name, target] of [
['plain-ts', 'targets/plain.ts'],
['module-mts', 'targets/module.mts'],
['common-cts', 'targets/common.cts'],
['directory', 'targets/directory/index.ts'],
] as const) {
await expect(resolver.resolve(name, files.parentURL()))
.resolves.toBe(pathToFileURL(files.path(target)).href)
}
await expect(resolver.resolve('tsx-implicit', files.parentURL())).resolves.toBeUndefined()
await expect(resolver.resolve('tsx-explicit', files.parentURL())).resolves.toBeUndefined()
await expect(resolver.resolve('missing', files.parentURL())).resolves.toBeUndefined()
})
it('anchors inherited paths at the config that declared them', async () => {
const files = fixture()
files.writeJson('consumer/package.json', { dependencies: { custom: '*' } })
files.write('targets/custom.ts')
files.writeJson('base.json', { compilerOptions: { paths: { custom: ['./targets/custom'] } } })
const customTsconfig = files.writeJson('configs/custom.json', { extends: '../base.json' })
const resolver = TsconfigPathsResolver.create(customTsconfig)
await expect(resolver.resolve('custom', files.parentURL()))
.resolves.toBe(pathToFileURL(files.path('targets/custom.ts')).href)
})
it('short-circuits matched aliases and delegates unsupported schemes or unmatched requests', async () => {
const files = fixture()
files.writeJson('consumer/package.json', { dependencies: { matched: '*' } })
const target = files.write('targets/matched.ts')
const tsconfigPath = files.writeJson('tsconfig.json', {
compilerOptions: { paths: { matched: ['./targets/matched'] } },
})
initialize({ tsconfigPath })
const context: ResolveHookContext = {
conditions: [],
importAttributes: {},
parentURL: files.parentURL(),
}
const nextResolve = vi.fn(async (
specifier: string,
_context: ResolveHookContext,
): Promise<ResolveFnOutput> => ({ url: `next:${specifier}` }))
await expect(resolveHook('matched', context, nextResolve))
.resolves.toEqual({ url: pathToFileURL(target).href, shortCircuit: true })
expect(nextResolve).not.toHaveBeenCalled()
for (const specifier of ['unmatched', 'node:fs', 'data:text/javascript,export default 1', 'https://example.test/mod.ts']) {
await expect(resolveHook(specifier, context, nextResolve)).resolves.toEqual({ url: `next:${specifier}` })
expect(nextResolve).toHaveBeenLastCalledWith(specifier, context)
}
})
})