@muyichengshayu/promptx 0.2.13 → 0.2.15

package/apps/server/src/runEventIngest.test.js

@@ -1,225 +0,0 @@
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import test from 'node:test'
-
-test('runEventIngest 会写入事件、同步 session 更新并推进 run 状态', async () => {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-run-ingest-'))
-  const originalCwd = process.cwd()
-  const originalDataDir = process.env.PROMPTX_DATA_DIR
-  const dataDir = path.join(tempDir, 'data')
-  fs.mkdirSync(dataDir, { recursive: true })
-  process.chdir(tempDir)
-  process.env.PROMPTX_DATA_DIR = dataDir
-
-  try {
-    const suffix = `test=${Date.now()}`
-    const { run } = await import(`./db.js?${suffix}`)
-    const { createRunEventIngestService } = await import(`./runEventIngest.js?${suffix}`)
-    const { getCodexRunById, listCodexRunEvents } = await import(`./codexRuns.js?${suffix}`)
-    const { getPromptxCodexSessionById } = await import(`./codexSessions.js?${suffix}`)
-
-    const now = new Date().toISOString()
-    run(
-      `INSERT INTO tasks (slug, edit_token, title, auto_title, last_prompt_preview, codex_session_id, visibility, expires_at, created_at, updated_at)
-       VALUES (?, ?, '', '', '', ?, 'private', NULL, ?, ?)`,
-      ['task-1', 'token-1', 'session-1', now, now]
-    )
-    run(
-      `INSERT INTO codex_sessions (id, title, engine, cwd, codex_thread_id, engine_session_id, engine_thread_id, engine_meta_json, created_at, updated_at)
-       VALUES (?, ?, 'codex', ?, '', '', '', '{}', ?, ?)`,
-      ['session-1', 'Session 1', tempDir, now, now]
-    )
-    run(
-      `INSERT INTO codex_sessions (id, title, engine, cwd, codex_thread_id, engine_session_id, engine_thread_id, engine_meta_json, created_at, updated_at)
-       VALUES (?, ?, 'claude-code', ?, '', 'claude-1', 'claude-1', ?, ?, ?)`,
-      ['session-2', 'Session 1', tempDir, JSON.stringify({ hidden: true, projectRootId: 'session-1' }), now, now]
-    )
-    run(
-      `INSERT INTO codex_sessions (id, title, engine, cwd, codex_thread_id, engine_session_id, engine_thread_id, engine_meta_json, created_at, updated_at)
-       VALUES (?, ?, 'opencode', ?, '', 'opencode-1', 'opencode-1', ?, ?, ?)`,
-      ['session-3', 'Session 1', tempDir, JSON.stringify({ hidden: true, projectRootId: 'session-1' }), now, now]
-    )
-    run(
-      `INSERT INTO codex_runs (id, task_slug, session_id, engine, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
-       VALUES (?, ?, ?, 'codex', ?, '[]', 'queued', '', '', ?, ?, NULL, NULL)`,
-      ['run-1', 'task-1', 'session-1', 'hello', now, now]
-    )
-
-    const broadcasts = []
-    const ingest = createRunEventIngestService({
-      broadcastServerEvent(type, payload = {}) {
-        broadcasts.push({ type, ...payload })
-      },
-    })
-
-    const eventsResult = ingest.ingestEvents([
-      {
-        runId: 'run-1',
-        seq: 1,
-        type: 'session.updated',
-        ts: now,
-        payload: {
-          type: 'session.updated',
-          session: {
-            id: 'session-1',
-            codexThreadId: 'thread-1',
-            engineThreadId: 'thread-1',
-            updatedAt: now,
-          },
-        },
-      },
-      {
-        runId: 'run-1',
-        seq: 2,
-        type: 'stdout',
-        ts: now,
-        payload: {
-          type: 'stdout',
-          text: 'hello world',
-        },
-      },
-    ])
-
-    assert.equal(eventsResult.ok, true)
-    assert.equal(listCodexRunEvents('run-1')?.length, 2)
-    assert.equal(getPromptxCodexSessionById('session-1')?.engineThreadId, 'thread-1')
-    assert.deepEqual(
-      listCodexRunEvents('run-1')?.[0]?.payload?.session?.agentBindings?.map((item) => item.engine),
-      ['codex', 'claude-code', 'opencode']
-    )
-    assert.deepEqual(
-      broadcasts
-        .filter((item) => item.type === 'run.event' && item.runId === 'run-1')
-        .map((item) => item.event?.payload?.session?.agentBindings?.map((binding) => binding.engine))
-        .find(Boolean),
-      ['codex', 'claude-code', 'opencode']
-    )
-
-    const runningRun = ingest.ingestStatus({
-      runId: 'run-1',
-      status: 'running',
-      startedAt: now,
-      heartbeatAt: now,
-    })
-    assert.equal(runningRun?.status, 'running')
-
-    const completedRun = ingest.ingestStatus({
-      runId: 'run-1',
-      status: 'completed',
-      responseMessage: 'done',
-      finishedAt: now,
-      heartbeatAt: now,
-      session: {
-        id: 'session-1',
-        codexThreadId: 'thread-1',
-        engineThreadId: 'thread-1',
-        updatedAt: now,
-      },
-    })
-
-    const storedRun = getCodexRunById('run-1')
-    assert.equal(completedRun?.status, 'completed')
-    assert.equal(storedRun?.status, 'completed')
-    assert.equal(storedRun?.responseMessage, 'done')
-    assert.equal(getPromptxCodexSessionById('session-1')?.engineThreadId, 'thread-1')
-    assert.ok(broadcasts.some((item) => item.type === 'run.event' && item.runId === 'run-1'))
-    assert.ok(broadcasts.some((item) => item.type === 'runs.changed' && item.runId === 'run-1'))
-    assert.ok(broadcasts.some((item) => item.type === 'sessions.changed' && item.sessionId === 'session-1'))
-
-    const lateHeartbeatAt = new Date(Date.now() + 1000).toISOString()
-    const staleRun = ingest.ingestStatus({
-      runId: 'run-1',
-      status: 'running',
-      responseMessage: 'should-be-ignored',
-      heartbeatAt: lateHeartbeatAt,
-      session: {
-        id: 'session-1',
-        codexThreadId: 'thread-1',
-        engineThreadId: 'thread-1',
-        updatedAt: lateHeartbeatAt,
-      },
-    })
-
-    const storedRunAfterLateHeartbeat = getCodexRunById('run-1')
-    assert.equal(staleRun?.status, 'completed')
-    assert.equal(storedRunAfterLateHeartbeat?.status, 'completed')
-    assert.equal(storedRunAfterLateHeartbeat?.responseMessage, 'done')
-  } finally {
-    process.chdir(originalCwd)
-    if (typeof originalDataDir === 'string') {
-      process.env.PROMPTX_DATA_DIR = originalDataDir
-    } else {
-      delete process.env.PROMPTX_DATA_DIR
-    }
-  }
-})
-
-test('runEventIngest 忽略 shell session 的身份字段补丁', async () => {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-run-ingest-shell-'))
-  const originalCwd = process.cwd()
-  const originalDataDir = process.env.PROMPTX_DATA_DIR
-  const dataDir = path.join(tempDir, 'data')
-  fs.mkdirSync(dataDir, { recursive: true })
-  process.chdir(tempDir)
-  process.env.PROMPTX_DATA_DIR = dataDir
-
-  try {
-    const suffix = `test=${Date.now()}-${Math.random().toString(36).slice(2)}`
-    const { get, run } = await import(`./db.js?${suffix}`)
-    const { createRunEventIngestService } = await import(`./runEventIngest.js?${suffix}`)
-
-    const now = new Date().toISOString()
-    const sessionId = 'session-shell-only'
-    const taskSlug = 'task-shell-only'
-    const runId = 'run-shell-only'
-    run(
-      `INSERT INTO tasks (slug, edit_token, title, auto_title, last_prompt_preview, codex_session_id, visibility, expires_at, created_at, updated_at)
-       VALUES (?, ?, '', '', '', ?, 'private', NULL, ?, ?)`,
-      [taskSlug, 'token-shell', sessionId, now, now]
-    )
-    run(
-      `INSERT INTO codex_sessions (id, title, engine, cwd, codex_thread_id, engine_session_id, engine_thread_id, engine_meta_json, created_at, updated_at)
-       VALUES (?, ?, 'codex', ?, ?, '', ?, '{}', ?, ?)`,
-      [sessionId, 'Session 1', tempDir, 'thread-original', 'thread-original', now, now]
-    )
-    run(
-      `INSERT INTO codex_runs (id, task_slug, session_id, engine, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
-       VALUES (?, ?, ?, 'shell', ?, '[]', 'queued', '', '', ?, ?, NULL, NULL)`,
-      [runId, taskSlug, sessionId, '!pwd', now, now]
-    )
-
-    const ingest = createRunEventIngestService()
-    ingest.ingestStatus({
-      runId,
-      status: 'completed',
-      responseMessage: '/tmp/demo',
-      finishedAt: now,
-      heartbeatAt: now,
-      session: {
-        id: sessionId,
-        engine: 'shell',
-        codexThreadId: 'thread-shell-overwrite',
-        engineThreadId: 'thread-shell-overwrite',
-        updatedAt: now,
-      },
-    })
-
-    const row = get(
-      `SELECT codex_thread_id, engine_thread_id
-       FROM codex_sessions
-       WHERE id = ?`,
-      [sessionId]
-    )
-    assert.equal(row?.codex_thread_id, 'thread-original')
-    assert.equal(row?.engine_thread_id, 'thread-original')
-  } finally {
-    process.chdir(originalCwd)
-    if (typeof originalDataDir === 'string') {
-      process.env.PROMPTX_DATA_DIR = originalDataDir
-    } else {
-      delete process.env.PROMPTX_DATA_DIR
-    }
-  }
-})

package/apps/server/src/runRecovery.test.js

@@ -1,73 +0,0 @@
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import test from 'node:test'
-
-test('runRecovery 会回收失联的 active run，并按状态落到 error / stop_timeout', async () => {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-run-recovery-'))
-  const originalCwd = process.cwd()
-  const originalDataDir = process.env.PROMPTX_DATA_DIR
-  const dataDir = path.join(tempDir, 'data')
-  fs.mkdirSync(dataDir, { recursive: true })
-  process.chdir(tempDir)
-  process.env.PROMPTX_DATA_DIR = dataDir
-
-  try {
-    const suffix = `test=${Date.now()}`
-    const { run } = await import(`./db.js?${suffix}`)
-    const { getCodexRunById } = await import(`./codexRuns.js?${suffix}`)
-    const { createRunRecoveryService } = await import(`./runRecovery.js?${suffix}`)
-
-    const staleAt = new Date(Date.now() - 60_000).toISOString()
-    run(
-      `INSERT INTO tasks (slug, edit_token, title, auto_title, last_prompt_preview, codex_session_id, visibility, expires_at, created_at, updated_at)
-       VALUES (?, ?, '', '', '', ?, 'private', NULL, ?, ?)`,
-      ['task-1', 'token-1', 'session-1', staleAt, staleAt]
-    )
-    run(
-      `INSERT INTO codex_sessions (id, title, engine, cwd, codex_thread_id, engine_session_id, engine_thread_id, engine_meta_json, created_at, updated_at)
-       VALUES (?, ?, 'codex', ?, '', '', '', '{}', ?, ?)`,
-      ['session-1', 'Session 1', tempDir, staleAt, staleAt]
-    )
-    run(
-      `INSERT INTO codex_runs (id, task_slug, session_id, engine, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
-       VALUES (?, ?, ?, 'codex', ?, '[]', 'running', '', '', ?, ?, ?, NULL)`,
-      ['run-1', 'task-1', 'session-1', 'hello', staleAt, staleAt, staleAt]
-    )
-    run(
-      `INSERT INTO codex_runs (id, task_slug, session_id, engine, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
-       VALUES (?, ?, ?, 'codex', ?, '[]', 'stopping', '', '', ?, ?, ?, NULL)`,
-      ['run-2', 'task-1', 'session-1', 'hello2', staleAt, staleAt, staleAt]
-    )
-
-    const recovered = []
-    const recovery = createRunRecoveryService({
-      staleThresholdMs: 5000,
-      onRecoveredRun(runRecord) {
-        recovered.push(runRecord.id)
-      },
-    })
-
-    const sweptRuns = recovery.sweep()
-    assert.equal(sweptRuns.length, 2)
-    assert.deepEqual(new Set(recovered), new Set(['run-1', 'run-2']))
-    assert.equal(getCodexRunById('run-1')?.status, 'error')
-    assert.equal(getCodexRunById('run-2')?.status, 'stop_timeout')
-
-    const diagnostics = recovery.getDiagnostics()
-    assert.equal(diagnostics.metrics.totalSweeps, 1)
-    assert.equal(diagnostics.metrics.totalRecovered, 2)
-    assert.equal(diagnostics.metrics.totalRecoveredToError, 1)
-    assert.equal(diagnostics.metrics.totalRecoveredToStopTimeout, 1)
-    assert.deepEqual(new Set(diagnostics.metrics.lastRecoveredRunIds), new Set(['run-1', 'run-2']))
-    assert.equal(diagnostics.config.staleThresholdMs, 5000)
-  } finally {
-    process.chdir(originalCwd)
-    if (typeof originalDataDir === 'string') {
-      process.env.PROMPTX_DATA_DIR = originalDataDir
-    } else {
-      delete process.env.PROMPTX_DATA_DIR
-    }
-  }
-})

package/apps/server/src/runnerClient.test.js

@@ -1,80 +0,0 @@
-import assert from 'node:assert/strict'
-import http from 'node:http'
-import test from 'node:test'
-
-import { getInternalAuthHeaderName, getInternalAuthToken } from './internalAuth.js'
-import { createRunnerClient } from './runnerClient.js'
-
-function startJsonServer(handler) {
-  return new Promise((resolve) => {
-    const server = http.createServer(handler)
-    server.listen(0, '127.0.0.1', () => {
-      const address = server.address()
-      resolve({
-        server,
-        baseUrl: `http://127.0.0.1:${address.port}`,
-      })
-    })
-  })
-}
-
-test('runnerClient attaches internal auth header and parses JSON response', async () => {
-  const { server, baseUrl } = await startJsonServer((request, response) => {
-    assert.equal(request.headers[getInternalAuthHeaderName()], getInternalAuthToken())
-    response.writeHead(200, { 'Content-Type': 'application/json' })
-    response.end(JSON.stringify({ ok: true }))
-  })
-
-  try {
-    const client = createRunnerClient({ baseUrl, timeoutMs: 1000 })
-    const payload = await client.getDiagnostics()
-    assert.deepEqual(payload, { ok: true })
-  } finally {
-    await new Promise((resolve) => server.close(resolve))
-  }
-})
-
-test('runnerClient fails fast on timeout', async () => {
-  const { server, baseUrl } = await startJsonServer((_request, response) => {
-    setTimeout(() => {
-      response.writeHead(200, { 'Content-Type': 'application/json' })
-      response.end(JSON.stringify({ ok: true }))
-    }, 700)
-  })
-
-  try {
-    const client = createRunnerClient({ baseUrl, timeoutMs: 500 })
-    await assert.rejects(
-      () => client.getDiagnostics(),
-      (error) => error?.statusCode === 504 && /超时/.test(String(error?.message || ''))
-    )
-  } finally {
-    await new Promise((resolve) => server.close(resolve))
-  }
-})
-
-test('runnerClient updates runner config with internal auth header', async () => {
-  const { server, baseUrl } = await startJsonServer(async (request, response) => {
-    assert.equal(request.method, 'PUT')
-    assert.equal(request.url, '/internal/config')
-    assert.equal(request.headers[getInternalAuthHeaderName()], getInternalAuthToken())
-
-    const chunks = []
-    for await (const chunk of request) {
-      chunks.push(chunk)
-    }
-    const body = JSON.parse(Buffer.concat(chunks).toString('utf8'))
-    assert.equal(body.maxConcurrentRuns, 3)
-
-    response.writeHead(200, { 'Content-Type': 'application/json' })
-    response.end(JSON.stringify({ ok: true, config: { maxConcurrentRuns: 3 } }))
-  })
-
-  try {
-    const client = createRunnerClient({ baseUrl, timeoutMs: 1000 })
-    const payload = await client.updateConfig({ maxConcurrentRuns: 3 })
-    assert.deepEqual(payload, { ok: true, config: { maxConcurrentRuns: 3 } })
-  } finally {
-    await new Promise((resolve) => server.close(resolve))
-  }
-})

package/apps/server/src/runnerDispatch.test.js

@@ -1,136 +0,0 @@
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import test from 'node:test'
-
-const sharedTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-runner-dispatch-'))
-const originalCwd = process.cwd()
-const originalDataDir = process.env.PROMPTX_DATA_DIR
-const sharedDataDir = path.join(sharedTempDir, 'data')
-fs.mkdirSync(sharedDataDir, { recursive: true })
-process.chdir(sharedTempDir)
-process.env.PROMPTX_DATA_DIR = sharedDataDir
-
-test.after(() => {
-  process.chdir(originalCwd)
-  if (typeof originalDataDir === 'string') {
-    process.env.PROMPTX_DATA_DIR = originalDataDir
-  } else {
-    delete process.env.PROMPTX_DATA_DIR
-  }
-})
-
-test('extractRunnerDispatchPatch prefers runner payload status and timestamps', async () => {
-  const { extractRunnerDispatchPatch } = await import(`./runnerDispatch.js?test=${Date.now()}`)
-
-  const patch = extractRunnerDispatchPatch({
-    status: 'starting',
-    startedAt: 'outer-start',
-    run: {
-      status: 'queued',
-      startedAt: 'inner-start',
-      finishedAt: 'inner-finish',
-    },
-  }, 'queued')
-
-  assert.deepEqual(patch, {
-    status: 'queued',
-    startedAt: 'inner-start',
-    finishedAt: 'inner-finish',
-  })
-})
-
-test('reconcileRunAfterRunnerDispatchError syncs run state from runner lookup', async () => {
-  const suffix = `test=${Date.now()}`
-  const { run } = await import(`./db.js?${suffix}`)
-  const { getCodexRunById } = await import(`./codexRuns.js?${suffix}`)
-  const { reconcileRunAfterRunnerDispatchError } = await import(`./runnerDispatch.js?${suffix}`)
-
-  const now = new Date().toISOString()
-  run(
-    `INSERT INTO tasks (slug, edit_token, title, auto_title, last_prompt_preview, codex_session_id, visibility, expires_at, created_at, updated_at)
-     VALUES (?, ?, '', '', '', ?, 'private', NULL, ?, ?)`,
-    ['task-1', 'token-1', 'session-1', now, now]
-  )
-  run(
-    `INSERT INTO codex_sessions (id, title, engine, cwd, codex_thread_id, engine_session_id, engine_thread_id, engine_meta_json, created_at, updated_at)
-     VALUES (?, ?, 'codex', ?, '', '', '', '{}', ?, ?)`,
-    ['session-1', 'Session 1', sharedTempDir, now, now]
-  )
-  run(
-    `INSERT INTO codex_runs (id, task_slug, session_id, engine, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
-     VALUES (?, ?, ?, 'codex', ?, '[]', 'queued', '', '', ?, ?, NULL, NULL)`,
-    ['run-1', 'task-1', 'session-1', 'hello', now, now]
-  )
-
-  const reconciled = await reconcileRunAfterRunnerDispatchError({
-    runId: 'run-1',
-    error: Object.assign(new Error('runner request timed out after 5000ms'), { statusCode: 504 }),
-    runnerClient: {
-      async getRun() {
-        return {
-          run: {
-            runId: 'run-1',
-            status: 'running',
-            startedAt: now,
-          },
-        }
-      },
-    },
-    fallbackStatus: 'queued',
-    logger: {
-      warn() {},
-    },
-  })
-
-  assert.equal(reconciled.pending, false)
-  assert.equal(reconciled.syncedFromRunner, true)
-  assert.equal(reconciled.run?.status, 'running')
-  assert.equal(getCodexRunById('run-1')?.status, 'running')
-})
-
-test('reconcileRunAfterRunnerDispatchError keeps run queued on timeout when runner lookup is unavailable', async () => {
-  const suffix = `test=${Date.now()}`
-  const { run } = await import(`./db.js?${suffix}`)
-  const { getCodexRunById } = await import(`./codexRuns.js?${suffix}`)
-  const { reconcileRunAfterRunnerDispatchError } = await import(`./runnerDispatch.js?${suffix}`)
-
-  const now = new Date().toISOString()
-  run(
-    `INSERT INTO tasks (slug, edit_token, title, auto_title, last_prompt_preview, codex_session_id, visibility, expires_at, created_at, updated_at)
-     VALUES (?, ?, '', '', '', ?, 'private', NULL, ?, ?)`,
-    ['task-2', 'token-2', 'session-2', now, now]
-  )
-  run(
-    `INSERT INTO codex_sessions (id, title, engine, cwd, codex_thread_id, engine_session_id, engine_thread_id, engine_meta_json, created_at, updated_at)
-     VALUES (?, ?, 'codex', ?, '', '', '', '{}', ?, ?)`,
-    ['session-2', 'Session 2', sharedTempDir, now, now]
-  )
-  run(
-    `INSERT INTO codex_runs (id, task_slug, session_id, engine, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
-     VALUES (?, ?, ?, 'codex', ?, '[]', 'queued', '', '', ?, ?, NULL, NULL)`,
-    ['run-2', 'task-2', 'session-2', 'hello', now, now]
-  )
-
-  const reconciled = await reconcileRunAfterRunnerDispatchError({
-    runId: 'run-2',
-    error: Object.assign(new Error('runner request timed out after 5000ms'), { statusCode: 504 }),
-    runnerClient: {
-      async getRun() {
-        const lookupError = new Error('runner lookup failed')
-        lookupError.statusCode = 503
-        throw lookupError
-      },
-    },
-    fallbackStatus: 'queued',
-    logger: {
-      warn() {},
-    },
-  })
-
-  assert.equal(reconciled.pending, true)
-  assert.equal(reconciled.syncedFromRunner, false)
-  assert.equal(reconciled.run?.status, 'queued')
-  assert.equal(getCodexRunById('run-2')?.status, 'queued')
-})

package/apps/server/src/systemConfig.test.js

@@ -1,112 +0,0 @@
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import test from 'node:test'
-
-test('system config module reads env override and stored values', async () => {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-system-config-'))
-  const originalDataDir = process.env.PROMPTX_DATA_DIR
-  const originalRunnerConcurrency = process.env.PROMPTX_RUNNER_MAX_CONCURRENT_RUNS
-  process.env.PROMPTX_DATA_DIR = tempDir
-
-  try {
-    const module = await import(`./systemConfig.js?test=${Date.now()}`)
-    const saved = module.writeStoredSystemConfig({
-      runner: {
-        maxConcurrentRuns: 3,
-      },
-    })
-
-    assert.equal(saved.runner.maxConcurrentRuns, 3)
-    assert.equal(fs.existsSync(module.getSystemConfigPath()), true)
-    assert.equal(module.readStoredSystemConfig().runner.maxConcurrentRuns, 3)
-    assert.equal(module.getSystemConfigManagedByEnv().runner.maxConcurrentRuns, false)
-    assert.equal(module.getSystemConfigForClient().runner.maxConcurrentRuns, 3)
-
-    process.env.PROMPTX_RUNNER_MAX_CONCURRENT_RUNS = '5'
-    const moduleWithEnv = await import(`./systemConfig.js?test=${Date.now()}-env`)
-    assert.equal(moduleWithEnv.getSystemConfigManagedByEnv().runner.maxConcurrentRuns, true)
-    assert.equal(moduleWithEnv.getSystemConfigForClient().runner.maxConcurrentRuns, 5)
-  } finally {
-    if (typeof originalDataDir === 'string') {
-      process.env.PROMPTX_DATA_DIR = originalDataDir
-    } else {
-      delete process.env.PROMPTX_DATA_DIR
-    }
-
-    if (typeof originalRunnerConcurrency === 'string') {
-      process.env.PROMPTX_RUNNER_MAX_CONCURRENT_RUNS = originalRunnerConcurrency
-    } else {
-      delete process.env.PROMPTX_RUNNER_MAX_CONCURRENT_RUNS
-    }
-  }
-})
-
-test('system config module redacts trusted proxy token for client payloads', async () => {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-system-config-'))
-  const originalDataDir = process.env.PROMPTX_DATA_DIR
-  process.env.PROMPTX_DATA_DIR = tempDir
-
-  try {
-    const module = await import(`./systemConfig.js?test=${Date.now()}-redact`)
-    module.writeStoredSystemConfig({
-      runner: {
-        maxConcurrentRuns: 3,
-      },
-      remoteCommandSecurity: {
-        mode: 'trusted-proxy',
-        trustedProxyToken: 'trusted-token',
-      },
-    })
-
-    assert.equal(module.getSystemConfigForRuntime().remoteCommandSecurity.trustedProxyToken, 'trusted-token')
-    assert.deepEqual(module.getSystemConfigForClient().remoteCommandSecurity, {
-      mode: 'trusted-proxy',
-      trustedProxyTokenConfigured: true,
-    })
-  } finally {
-    if (typeof originalDataDir === 'string') {
-      process.env.PROMPTX_DATA_DIR = originalDataDir
-    } else {
-      delete process.env.PROMPTX_DATA_DIR
-    }
-  }
-})
-
-test('system config module clears trusted proxy token when mode is not trusted-proxy', async () => {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-system-config-'))
-  const originalDataDir = process.env.PROMPTX_DATA_DIR
-  process.env.PROMPTX_DATA_DIR = tempDir
-
-  try {
-    const module = await import(`./systemConfig.js?test=${Date.now()}-clear-token`)
-    module.writeStoredSystemConfig({
-      remoteCommandSecurity: {
-        mode: 'trusted-proxy',
-        trustedProxyToken: 'trusted-token',
-      },
-    })
-
-    const saved = module.writeStoredSystemConfig({
-      remoteCommandSecurity: {
-        mode: 'relay',
-      },
-    })
-
-    assert.deepEqual(saved.remoteCommandSecurity, {
-      mode: 'relay',
-      trustedProxyToken: '',
-    })
-    assert.deepEqual(module.readStoredSystemConfig().remoteCommandSecurity, {
-      mode: 'relay',
-      trustedProxyToken: '',
-    })
-  } finally {
-    if (typeof originalDataDir === 'string') {
-      process.env.PROMPTX_DATA_DIR = originalDataDir
-    } else {
-      delete process.env.PROMPTX_DATA_DIR
-    }
-  }
-})