Merge branch 'codex/goal-commands' into codex/ralph-tool

# Conflicts: # examples/repl-agent/README.md # examples/repl-agent/composition.md # examples/repl-agent/cordis.yml
2026-07-20 22:25:16 +08:00
parent 30d2ec4a95 5c301febbf
commit 1b04e8eb2b
249 changed files with 2921 additions and 4563 deletions
@@ -12,8 +12,8 @@
  config:
    cwd: !!js process.cwd()

- id: stdio-agent
-  name: '@deepseek-ai/dsh-stdio-demo'
+- id: tui-agent
+  name: '@deepseek-ai/dsh-tui-demo'
  config:
    provider: tui-scripted
    model: tui-scripted-model
@@ -22,6 +22,4 @@
      maxBytes: 65536
    welcome: 'scripted TUI ready.'
    ui:
-      mode: tui
-      tui:
-        showReasoning: true
+      showReasoning: true
@@ -0,0 +1,127 @@
+import { spawn } from 'node:child_process'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { resolveExampleLaunch } from '@deepseek-ai/dsh-loader-smoke'
+
+const PTY_DRIVER = String.raw`
+import errno, json, os, pty, select, signal, sys, time
+node, launch_args_json, launch_env_json, cwd, actions_json, expected_exit, timeout_seconds = sys.argv[1:]
+env = os.environ.copy()
+env.update(json.loads(launch_env_json))
+env.update({"COLUMNS": "100", "LINES": "30"})
+actions = json.loads(actions_json)
+pid, fd = pty.fork()
+if pid == 0:
+    os.chdir(cwd)
+    os.execvpe(node, [node, *json.loads(launch_args_json)], env)
+
+output = bytearray()
+action_index = 0
+deadline = time.monotonic() + float(timeout_seconds)
+status = None
+while time.monotonic() < deadline:
+    ready, _, _ = select.select([fd], [], [], 0.05)
+    if ready:
+        try:
+            chunk = os.read(fd, 65536)
+        except OSError as error:
+            if error.errno != errno.EIO:
+                raise
+            chunk = b""
+        if chunk:
+            output.extend(chunk)
+    while action_index < len(actions) and actions[action_index]["waitFor"].encode() in output:
+        os.write(fd, actions[action_index]["send"].encode())
+        action_index += 1
+    waited, candidate = os.waitpid(pid, os.WNOHANG)
+    if waited == pid:
+        status = candidate
+        break
+
+if status is None:
+    os.kill(pid, signal.SIGKILL)
+    _, status = os.waitpid(pid, 0)
+sys.stdout.buffer.write(output)
+if action_index != len(actions):
+    sys.stderr.write(f"completed {action_index}/{len(actions)} PTY actions before timeout\n")
+    sys.exit(124)
+actual_exit = os.waitstatus_to_exitcode(status)
+if actual_exit != int(expected_exit):
+    sys.stderr.write(f"expected exit {expected_exit}, got {actual_exit}\n")
+    sys.exit(125)
+`
+
+/** One terminal action sent after its marker has rendered. */
+interface TuiPtyAction {
+  readonly waitFor: string
+  readonly send: string
+}
+
+/** Inputs for a keyless real-Loader TUI process smoke. */
+export interface TuiPtySmokeOptions {
+  readonly label: string
+  readonly tempDirPrefix: string
+  readonly binScript: string
+  readonly configPath: string
+  readonly tsconfigPath: string
+  readonly actions?: readonly TuiPtyAction[]
+  readonly env?: Readonly<NodeJS.ProcessEnv>
+  readonly expectedExitCode?: number
+  readonly timeoutMs?: number
+}
+
+/**
+ * Boot an example in a real pseudo-terminal, drive marker-gated input, and
+ * return the captured terminal bytes after the expected process exit.
+ * @param options - launch paths, environment, actions, and expected exit code.
+ * @returns complete pseudo-terminal output.
+ */
+export async function runTuiPtySmoke(options: TuiPtySmokeOptions): Promise<string> {
+  const cwd = await mkdtemp(join(tmpdir(), options.tempDirPrefix))
+  const timeoutMs = options.timeoutMs ?? 25_000
+  try {
+    const launch = resolveExampleLaunch({
+      srcBin: options.binScript,
+      configArgs: [options.configPath],
+      tsconfigPath: options.tsconfigPath,
+      exposeInternals: true,
+      env: {
+        DSH_HOME: join(cwd, '.dsh'),
+        DSH_AGENTS_HOME: join(cwd, '.agents'),
+        ...options.env,
+      },
+    })
+    return await new Promise((resolve, reject) => {
+      const child = spawn('python3', [
+        '-c',
+        PTY_DRIVER,
+        launch.command,
+        JSON.stringify(launch.args),
+        JSON.stringify(launch.env),
+        cwd,
+        JSON.stringify(options.actions ?? []),
+        String(options.expectedExitCode ?? 0),
+        String(timeoutMs / 1_000),
+      ], { stdio: ['ignore', 'pipe', 'pipe'] })
+      let stdout = ''
+      let stderr = ''
+      child.stdout.setEncoding('utf8')
+      child.stdout.on('data', (chunk: string) => { stdout += chunk })
+      child.stderr.setEncoding('utf8')
+      child.stderr.on('data', (chunk: string) => { stderr += chunk })
+      const timer = setTimeout(() => {
+        child.kill('SIGKILL')
+        reject(new Error(`${options.label} PTY driver did not exit. stdout:\n${stdout}\nstderr:\n${stderr}`))
+      }, timeoutMs + 5_000)
+      child.once('error', (error) => { clearTimeout(timer); reject(error) })
+      child.once('exit', (code) => {
+        clearTimeout(timer)
+        if (code === 0) resolve(stdout)
+        else reject(new Error(`${options.label} PTY driver exited ${String(code)}. stdout:\n${stdout}\nstderr:\n${stderr}`))
+      })
+    })
+  } finally {
+    await rm(cwd, { recursive: true, force: true })
+  }
+}
@@ -1,157 +1,43 @@
-import { spawn } from 'node:child_process'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { describe, expect, it } from 'vitest'
-import { LOADER_SMOKE_TEST_TIMEOUT_MS, resolveExampleLaunch } from '@deepseek-ai/dsh-loader-smoke'
+import { LOADER_SMOKE_TEST_TIMEOUT_MS } from '@deepseek-ai/dsh-loader-smoke'
+import { runTuiPtySmoke } from './pty-harness.ts'

-const binScript = fileURLToPath(new URL('../../../packages/examples/stdio-demo/src/bin.ts', import.meta.url))
+const binScript = fileURLToPath(new URL('../../../packages/examples/tui-demo/src/bin.ts', import.meta.url))
 const configPath = fileURLToPath(new URL('../cordis.yml', import.meta.url))
 const scriptedConfigPath = fileURLToPath(new URL('./fixtures/tui-scripted.cordis.yml', import.meta.url))
 const tsconfigPath = fileURLToPath(new URL('../../../tsconfig.json', import.meta.url))

-const PTY_DRIVER = String.raw`
-import errno, json, os, pty, select, signal, sys, time
-node, launch_args_json, launch_env_json, cwd, resume_session_id, scenario = sys.argv[1:]
-env = os.environ.copy()
-env.update(json.loads(launch_env_json))
-env.update({
-    "COLUMNS": "100",
-    "LINES": "30",
-})
-if resume_session_id:
-    env["RESUME_SESSION_ID"] = resume_session_id
-pid, fd = pty.fork()
-if pid == 0:
-    os.chdir(cwd)
-    os.execvpe(node, [node, *json.loads(launch_args_json)], env)
-
-output = bytearray()
-answered_question = False
-sent_prompt = False
-sent_exit = False
-deadline = time.monotonic() + 25
-status = None
-while time.monotonic() < deadline:
-    ready, _, _ = select.select([fd], [], [], 0.05)
-    if ready:
-        try:
-            chunk = os.read(fd, 65536)
-        except OSError as error:
-            if error.errno != errno.EIO:
-                raise
-            chunk = b""
-        if chunk:
-            output.extend(chunk)
-    if scenario == "conversation" and not sent_prompt and b"scripted TUI ready." in output:
-        os.write(fd, b"exercise the TUI\r")
-        sent_prompt = True
-    if scenario == "conversation" and sent_prompt and not answered_question and b"How should the scripted run proceed?" in output:
-        os.write(fd, b"\r")
-        answered_question = True
-    if scenario == "conversation" and answered_question and not sent_exit and b"Decision received. Scripted TUI run complete." in output:
-        os.write(fd, b"/exit\r")
-        sent_exit = True
-    if scenario == "boot" and not sent_exit and b"TUI agent ready." in output:
-        os.write(fd, b"/exit\r")
-        sent_exit = True
-    waited, candidate = os.waitpid(pid, os.WNOHANG)
-    if waited == pid:
-        status = candidate
-        break
-
-if status is None:
-    os.kill(pid, signal.SIGKILL)
-    _, status = os.waitpid(pid, 0)
-sys.stdout.buffer.write(output)
-if scenario == "resume-failure":
-    if b'ui-tui: session "missing-session" failed to start:' not in output:
-        sys.stderr.write("TUI did not render the startup failure before timeout\n")
-        sys.exit(126)
-    if not os.WIFEXITED(status) or os.WEXITSTATUS(status) != 1:
-        sys.stderr.write("TUI startup failure did not exit with status 1\n")
-        sys.exit(127)
-elif scenario == "conversation":
-    if not sent_prompt:
-        sys.stderr.write("TUI did not render the scripted welcome marker before timeout\n")
-        sys.exit(128)
-    if not answered_question:
-        sys.stderr.write("TUI did not render the user-question dialog before timeout\n")
-        sys.exit(129)
-    if not sent_exit:
-        sys.stderr.write("TUI did not finish the scripted tool round-trip before timeout\n")
-        sys.exit(130)
-    if not os.WIFEXITED(status) or os.WEXITSTATUS(status) != 0:
-        sys.stderr.write("TUI scripted conversation did not exit cleanly\n")
-        sys.exit(131)
-else:
-    if not sent_exit:
-        sys.stderr.write("TUI did not render its welcome marker before timeout\n")
-        sys.exit(124)
-    if not os.WIFEXITED(status) or os.WEXITSTATUS(status) != 0:
-        sys.stderr.write("TUI child did not exit cleanly\n")
-        sys.exit(125)
-`
-
-interface TuiLoaderSmokeOptions {
-  config?: string
-  resumeSessionId?: string
-  scenario?: 'boot' | 'conversation' | 'resume-failure'
-}
-
-async function runTuiLoaderSmoke(options: TuiLoaderSmokeOptions = {}): Promise<string> {
-  const cwd = await mkdtemp(join(tmpdir(), 'tui-agent-smoke-'))
-  try {
-    const launch = resolveExampleLaunch({
-      srcBin: binScript,
-      configArgs: [options.config ?? configPath],
-      tsconfigPath,
-      exposeInternals: true,
-      env: {
-        DEEPSEEK_API_KEY: 'keyless-tui-no-call',
-        DSH_HOME: join(cwd, '.dsh'),
-        DSH_AGENTS_HOME: join(cwd, '.agents'),
-      },
-    })
-    return await new Promise((resolve, reject) => {
-      const child = spawn('python3', [
-        '-c',
-        PTY_DRIVER,
-        launch.command,
-        JSON.stringify(launch.args),
-        JSON.stringify(launch.env),
-        cwd,
-        options.resumeSessionId ?? '',
-        options.scenario ?? 'boot',
-      ], { stdio: ['ignore', 'pipe', 'pipe'] })
-      let stdout = ''
-      let stderr = ''
-      child.stdout.setEncoding('utf8')
-      child.stdout.on('data', (chunk: string) => { stdout += chunk })
-      child.stderr.setEncoding('utf8')
-      child.stderr.on('data', (chunk: string) => { stderr += chunk })
-      child.once('error', reject)
-      child.once('exit', (code) => {
-        if (code === 0) resolve(stdout)
-        else reject(new Error(`TUI PTY smoke exited ${String(code)}. stdout:\n${stdout}\nstderr:\n${stderr}`))
-      })
-    })
-  } finally {
-    await rm(cwd, { recursive: true, force: true })
-  }
-}
-
-describe('tui-agent keyless smoke (real Loader tree in a PTY)', () => {
+// The Python PTY driver imports the POSIX-only pty and termios modules.
+describe.skipIf(process.platform === 'win32')('tui-agent keyless smoke (real Loader tree in a PTY)', () => {
  it('boots pi-tui, renders the configured banner, accepts /exit, and restores the terminal', async () => {
-    const output = await runTuiLoaderSmoke()
+    const output = await runTuiPtySmoke({
+      label: 'tui-agent boot',
+      tempDirPrefix: 'tui-agent-smoke-',
+      binScript,
+      configPath,
+      tsconfigPath,
+      env: { DEEPSEEK_API_KEY: 'keyless-tui-no-call' },
+      actions: [{ waitFor: 'TUI agent ready.', send: '/exit\r' }],
+    })
    expect(output).toContain('DEEPSEEK')
    expect(output).toContain('TUI agent ready.')
    expect(output).toContain('\u001B[?2004l')
  }, LOADER_SMOKE_TEST_TIMEOUT_MS)

  it('streams a response, answers a user-question dialog, completes the tool round-trip, and exits cleanly', async () => {
-    const output = await runTuiLoaderSmoke({ config: scriptedConfigPath, scenario: 'conversation' })
+    const output = await runTuiPtySmoke({
+      label: 'tui-agent conversation',
+      tempDirPrefix: 'tui-agent-conversation-',
+      binScript,
+      configPath: scriptedConfigPath,
+      tsconfigPath,
+      actions: [
+        { waitFor: 'scripted TUI ready.', send: 'exercise the TUI\r' },
+        { waitFor: 'How should the scripted run proceed?', send: '\r' },
+        { waitFor: 'Decision received. Scripted TUI run complete.', send: '/exit\r' },
+      ],
+    })
    expect(output).toContain('I need one decision before I continue.')
    expect(output).toContain(String.raw`\x1b]2;MODEL_CONTROLLED\x07`)
    expect(output).toContain(String.raw`\x1b[999CMODEL_CURSOR`)
@@ -159,14 +45,23 @@ describe('tui-agent keyless smoke (real Loader tree in a PTY)', () => {
    expect(output).not.toContain('\u001B]2;MODEL_CONTROLLED\u0007')
    expect(output).not.toContain('\u001B[999CMODEL_CURSOR')
    expect(output).not.toContain('\u009B31mMODEL_C1')
-    expect(output).toContain('How should the scripted run proceed?')
    expect(output).toContain('Safe')
-    expect(output).toContain('Decision received. Scripted TUI run complete.')
    expect(output).toContain('\u001B[?2004l')
  }, LOADER_SMOKE_TEST_TIMEOUT_MS)

  it('prints a config-resume failure and exits instead of leaving a blank terminal', async () => {
-    const output = await runTuiLoaderSmoke({ resumeSessionId: 'missing-session', scenario: 'resume-failure' })
+    const output = await runTuiPtySmoke({
+      label: 'tui-agent resume failure',
+      tempDirPrefix: 'tui-agent-resume-',
+      binScript,
+      configPath,
+      tsconfigPath,
+      env: {
+        DEEPSEEK_API_KEY: 'keyless-tui-no-call',
+        RESUME_SESSION_ID: 'missing-session',
+      },
+      expectedExitCode: 1,
+    })
    expect(output).toContain('ui-tui: session "missing-session" failed to start:')
  }, LOADER_SMOKE_TEST_TIMEOUT_MS)
 })