108 lines
5.1 KiB
TypeScript
108 lines
5.1 KiB
TypeScript
/**
|
|
* Keyless REAL-composition coverage for parent-session cwd inheritance across
|
|
* the SDK wire: a test-only cordis.yml boots the headless app through the
|
|
* Loader with the SDK backend's `cwd` omitted, a scripted model delegates
|
|
* once, and the child — a COMPLETE second harness runtime booted from its own
|
|
* cordis.yml and driven over stdio JSON-RPC — echoes where it actually ran.
|
|
* Both the parent's tool result and the child's own persisted session log
|
|
* must carry the parent session's cwd. Mock-only composition, so only this
|
|
* keyless tier applies (the with-key tier lives in subagent-sdk.e2e.ts).
|
|
*/
|
|
|
|
import { realpathSync } from 'node:fs'
|
|
import { readFile, readdir } from 'node:fs/promises'
|
|
import { join } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { describe, expect, it } from 'vitest'
|
|
import { type SessionEvent } from '@deepseek-ai/dsh-session'
|
|
import { resolveExampleLaunch, runLoaderSmoke } from '@deepseek-ai/dsh-loader-smoke'
|
|
|
|
const fixtureDir = new URL('../../../../examples/jsonrpc-agent/tests/fixtures/subagent/subagent-dsh-sdk/', import.meta.url)
|
|
const driver = fileURLToPath(new URL('driver.ts', fixtureDir))
|
|
const configPath = fileURLToPath(new URL('cordis.yml', fixtureDir))
|
|
const childConfigPath = fileURLToPath(new URL('child.cordis.yml', fixtureDir))
|
|
const runtimeBin = fileURLToPath(new URL('../../../../packages/examples/jsonrpc-demo/src/bin.ts', import.meta.url))
|
|
const repoTsconfig = fileURLToPath(new URL('../../../../tsconfig.json', import.meta.url))
|
|
|
|
async function jsonlFiles(dir: string): Promise<string[]> {
|
|
const entries = await readdir(dir, { withFileTypes: true })
|
|
const paths = await Promise.all(entries.map(async (entry) => {
|
|
const path = join(dir, entry.name)
|
|
if (entry.isDirectory()) return jsonlFiles(path)
|
|
return entry.isFile() && entry.name.endsWith('.jsonl') ? [path] : []
|
|
}))
|
|
return paths.flat()
|
|
}
|
|
|
|
async function sessionEvents(log: string): Promise<SessionEvent[]> {
|
|
const lines = (await readFile(log, 'utf8')).trimEnd().split('\n')
|
|
return lines.slice(1).map(line => JSON.parse(line) as SessionEvent)
|
|
}
|
|
|
|
describe('SDK subagent cwd inheritance through a real cordis.yml', () => {
|
|
it('runs the child runtime in the parent session workspace', async () => {
|
|
// The child launch honors the same src/lib mode as the driving harness,
|
|
// per the shared example-launch resolver (testing policy forbids
|
|
// hand-written `--import tsx` argv for example subprocesses).
|
|
const childLaunch = resolveExampleLaunch({
|
|
srcBin: runtimeBin,
|
|
configArgs: [childConfigPath],
|
|
tsconfigPath: repoTsconfig,
|
|
})
|
|
|
|
let events: SessionEvent[] = []
|
|
let childEvents: SessionEvent[] = []
|
|
let workspace = ''
|
|
const { stderr } = await runLoaderSmoke({
|
|
label: 'dsh-sdk-subagent cwd composition smoke',
|
|
tempDirPrefix: 'dsh-sdk-subagent-cwd-e2e-',
|
|
binScript: driver,
|
|
libBinScript: driver,
|
|
configPath,
|
|
tsconfigPath: repoTsconfig,
|
|
// Two complete harness runtimes boot in sequence (driver, then the SDK
|
|
// child); from-source tsx boots under load need more than the default
|
|
// 30s window.
|
|
processTimeoutMs: 120_000,
|
|
env: {
|
|
DSH_TEST_CHILD_COMMAND: childLaunch.command,
|
|
DSH_TEST_CHILD_ARGS: JSON.stringify(childLaunch.args),
|
|
DSH_TEST_CHILD_ENV: JSON.stringify({
|
|
...Object.fromEntries(Object.entries(childLaunch.env).filter(([, value]) => value !== undefined)),
|
|
}),
|
|
},
|
|
inspect: async (cwd) => {
|
|
// The child reports realpaths; canonicalize the temp workspace to match.
|
|
workspace = realpathSync(cwd)
|
|
const parentLogs = await jsonlFiles(join(cwd, '.sessions'))
|
|
expect(parentLogs).toHaveLength(1)
|
|
events = await sessionEvents(parentLogs[0] as string)
|
|
// The child runtime persisted its own transcript in ITS cwd — which
|
|
// must be the parent session's workspace for the inheritance to hold.
|
|
const childLogs = await jsonlFiles(join(cwd, '.child-sessions'))
|
|
expect(childLogs).toHaveLength(1)
|
|
childEvents = await sessionEvents(childLogs[0] as string)
|
|
},
|
|
})
|
|
expect(stderr).not.toContain('UNHANDLED')
|
|
|
|
// The parent's tool result carries the child model's echo of its real
|
|
// process.cwd() — the parent session's workspace, never the harness
|
|
// process's launch directory.
|
|
const results = events.filter(event => event.type === 'tool/result')
|
|
expect(results).toHaveLength(1)
|
|
const resultText = results[0]!.data.message.content[0].content
|
|
.filter(block => block.type === 'text')
|
|
.map(block => block.text)
|
|
.join('')
|
|
expect(resultText).toBe(`child cwd: ${workspace}`)
|
|
|
|
// The child ran a real turn of its own: user message in, assistant out.
|
|
expect(childEvents.some(event => event.type === 'user/message')).toBe(true)
|
|
const childAnswers = childEvents.filter(event => event.type === 'assistant/message')
|
|
expect(childAnswers.length).toBeGreaterThan(0)
|
|
// 15s of vitest headroom past the subprocess deadline, mirroring
|
|
// LOADER_SMOKE_TEST_TIMEOUT_MS's margin over the default window.
|
|
}, 135_000)
|
|
})
|