@muyichengshayu/promptx 0.2.13 → 0.2.15

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

@@ -1,134 +0,0 @@
-import assert from 'node:assert/strict'
-import Fastify from 'fastify'
-import test from 'node:test'
-
-import { buildInternalAuthHeaders } from './internalAuth.js'
-import {
-  registerInternalRunnerRoutes,
-  registerRealtimeRoutes,
-} from './internalRoutes.js'
-
-test('internal runner routes require auth and notify completed runs', async () => {
-  const events = []
-  const notified = []
-  const app = Fastify()
-
-  registerInternalRunnerRoutes(app, {
-    runEventIngestService: {
-      ingestEvents(items) {
-        events.push(...items)
-        return { ok: true, count: items.length }
-      },
-      ingestStatus(payload) {
-        return {
-          ...payload,
-          id: payload.runId,
-          completed: true,
-        }
-      },
-    },
-    taskAutomationService: {
-      notifyRun(taskSlug, runId) {
-        notified.push({ taskSlug, runId })
-        return Promise.resolve()
-      },
-    },
-  })
-  await app.ready()
-
-  try {
-    const unauthorized = await app.inject({
-      method: 'POST',
-      url: '/internal/runner-events',
-      payload: { items: [] },
-    })
-    assert.equal(unauthorized.statusCode, 401)
-
-    const eventsResponse = await app.inject({
-      method: 'POST',
-      url: '/internal/runner-events',
-      headers: buildInternalAuthHeaders(),
-      payload: {
-        items: [{ runId: 'run-1', type: 'stdout' }],
-      },
-    })
-    assert.equal(eventsResponse.statusCode, 200)
-    assert.equal(events.length, 1)
-
-    const statusResponse = await app.inject({
-      method: 'POST',
-      url: '/internal/runner-status',
-      headers: buildInternalAuthHeaders(),
-      payload: {
-        runId: 'run-1',
-        taskSlug: 'task-1',
-        status: 'completed',
-      },
-    })
-    assert.equal(statusResponse.statusCode, 200)
-    assert.deepEqual(notified, [{ taskSlug: 'task-1', runId: 'run-1' }])
-  } finally {
-    await app.close()
-  }
-})
-
-test('internal runner events route accepts payloads larger than default body limit', async () => {
-  const app = Fastify()
-  let acceptedCount = 0
-
-  registerInternalRunnerRoutes(app, {
-    runEventIngestService: {
-      ingestEvents(items) {
-        acceptedCount = items.length
-        return { ok: true, count: items.length }
-      },
-      ingestStatus() {
-        return null
-      },
-    },
-    taskAutomationService: {
-      notifyRun() {
-        return Promise.resolve()
-      },
-    },
-  })
-  await app.ready()
-
-  try {
-    const largeText = 'x'.repeat(2 * 1024 * 1024)
-    const response = await app.inject({
-      method: 'POST',
-      url: '/internal/runner-events',
-      headers: buildInternalAuthHeaders(),
-      payload: {
-        items: [{ runId: 'run-large', seq: 1, type: 'stdout', payload: { text: largeText } }],
-      },
-    })
-
-    assert.equal(response.statusCode, 200)
-    assert.equal(acceptedCount, 1)
-  } finally {
-    await app.close()
-  }
-})
-
-test('realtime routes are registered on the app', async () => {
-  const app = Fastify()
-
-  registerRealtimeRoutes(app, {
-    sseHub: {
-      addClient() {
-        return () => {}
-      },
-      write() {},
-    },
-  })
-  await app.ready()
-
-  try {
-    const routes = app.printRoutes()
-    assert.match(routes, /api\/events\/stream/)
-  } finally {
-    await app.close()
-  }
-})

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

@@ -1,154 +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, { after } from 'node:test'
-
-const sharedTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-maintenance-suite-'))
-const sharedDataDir = path.join(sharedTempDir, 'data')
-const originalDataDir = process.env.PROMPTX_DATA_DIR
-fs.mkdirSync(sharedDataDir, { recursive: true })
-process.env.PROMPTX_DATA_DIR = sharedDataDir
-
-let closeDatabaseForTesting = () => {}
-
-after(() => {
-  closeDatabaseForTesting()
-  if (typeof originalDataDir === 'string') {
-    process.env.PROMPTX_DATA_DIR = originalDataDir
-  } else {
-    delete process.env.PROMPTX_DATA_DIR
-  }
-  fs.rmSync(sharedTempDir, { recursive: true, force: true })
-})
-
-test('maintenance service prunes stale tmp files and runner check directories', async () => {
-  const tempDir = path.join(sharedTempDir, 'fs-cleanup')
-  const tmpDir = path.join(tempDir, 'tmp')
-  const reportDir = path.join(tempDir, 'reports', 'runner-checks')
-  fs.mkdirSync(tmpDir, { recursive: true })
-  fs.mkdirSync(reportDir, { recursive: true })
-
-  const staleTmpFile = path.join(tmpDir, 'stale.tmp')
-  const freshTmpFile = path.join(tmpDir, 'fresh.tmp')
-  const staleReportDir = path.join(reportDir, 'old-report')
-  const freshReportDir = path.join(reportDir, 'new-report')
-
-  fs.writeFileSync(staleTmpFile, 'stale')
-  fs.writeFileSync(freshTmpFile, 'fresh')
-  fs.mkdirSync(staleReportDir, { recursive: true })
-  fs.mkdirSync(freshReportDir, { recursive: true })
-
-  const staleTime = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000)
-  fs.utimesSync(staleTmpFile, staleTime, staleTime)
-  fs.utimesSync(staleReportDir, staleTime, staleTime)
-
-  const { createMaintenanceService } = await import(`./maintenance.js?test=${Date.now()}`)
-  const plainDbModule = await import('./db.js')
-  closeDatabaseForTesting = plainDbModule.closeDatabaseForTesting
-  const service = createMaintenanceService({
-    tmpDir,
-    cleanupIntervalMs: 60_000,
-    reportRetentionMs: 24 * 60 * 60 * 1000,
-    tmpFileRetentionMs: 24 * 60 * 60 * 1000,
-    reportDirs: [reportDir],
-    runEventRetentionMs: 365 * 24 * 60 * 60 * 1000,
-  })
-
-  const diagnosticsBefore = service.getDiagnostics()
-  assert.equal(diagnosticsBefore.lastCleanup.startedAt, '')
-
-  const result = service.runCleanup()
-
-  assert.equal(fs.existsSync(staleTmpFile), false)
-  assert.equal(fs.existsSync(freshTmpFile), true)
-  assert.equal(fs.existsSync(staleReportDir), false)
-  assert.equal(fs.existsSync(freshReportDir), true)
-  assert.equal(result.removedTmpFiles >= 1, true)
-})
-
-test('maintenance service prunes stale run events and runs sqlite maintenance', async () => {
-  const dbModule = await import('./db.js')
-  const { run } = dbModule
-  const { listCodexRunEvents } = await import('./codexRuns.js')
-  const { createMaintenanceService } = await import(`./maintenance.js?test-db=${Date.now()}`)
-
-  const staleFinishedAt = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString()
-  const recentFinishedAt = 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-maint-1', 'token-1', 'session-maint-1', staleFinishedAt, staleFinishedAt]
-  )
-  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-maint-1', 'Session Maint 1', sharedTempDir, staleFinishedAt, staleFinishedAt]
-  )
-  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', ?, '[]', 'completed', '', '', ?, ?, ?, ?)`,
-    ['run-stale', 'task-maint-1', 'session-maint-1', 'old', staleFinishedAt, staleFinishedAt, staleFinishedAt, staleFinishedAt]
-  )
-  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', ?, '[]', 'completed', '', '', ?, ?, ?, ?)`,
-    ['run-capped', 'task-maint-1', 'session-maint-1', 'new', recentFinishedAt, recentFinishedAt, recentFinishedAt, recentFinishedAt]
-  )
-  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-active', 'task-maint-1', 'session-maint-1', 'active', recentFinishedAt, recentFinishedAt, recentFinishedAt]
-  )
-
-  for (let seq = 1; seq <= 3; seq += 1) {
-    run(
-      `INSERT INTO codex_run_events (run_id, seq, event_type, payload_json, created_at)
-       VALUES (?, ?, 'event', '{}', ?)`,
-      ['run-stale', seq, staleFinishedAt]
-    )
-  }
-  for (let seq = 1; seq <= 5; seq += 1) {
-    run(
-      `INSERT INTO codex_run_events (run_id, seq, event_type, payload_json, created_at)
-       VALUES (?, ?, 'event', '{}', ?)`,
-      ['run-capped', seq, recentFinishedAt]
-    )
-  }
-  for (let seq = 1; seq <= 5; seq += 1) {
-    run(
-      `INSERT INTO codex_run_events (run_id, seq, event_type, payload_json, created_at)
-       VALUES (?, ?, 'event', '{}', ?)`,
-      ['run-active', seq, recentFinishedAt]
-    )
-  }
-
-  const service = createMaintenanceService({
-    tmpDir: path.join(sharedTempDir, 'tmp-db-cleanup'),
-    cleanupIntervalMs: 60_000,
-    runEventRetentionMs: 24 * 60 * 60 * 1000,
-    maxRunEventsPerRun: 2,
-    dbVacuumIntervalMs: 60_000,
-  })
-
-  const result = service.runCleanup({ forceDbVacuum: true })
-
-  assert.equal(result.runEvents.removedByRetention, 3)
-  assert.equal(result.runEvents.removedByCount, 3)
-  assert.equal(result.runEvents.removedTotal, 6)
-  assert.equal(result.dbMaintenance.vacuumed, true)
-  assert.equal(listCodexRunEvents('run-stale')?.length, 0)
-  assert.deepEqual(
-    (listCodexRunEvents('run-capped') || []).map((item) => item.seq),
-    [4, 5]
-  )
-  assert.equal(listCodexRunEvents('run-active')?.length, 5)
-
-  const diagnostics = service.getDiagnostics()
-  assert.equal(diagnostics.runEventRetentionMs, 24 * 60 * 60 * 1000)
-  assert.equal(diagnostics.maxRunEventsPerRun, 2)
-  assert.equal(diagnostics.lastCleanup.runEvents.removedTotal, 6)
-  assert.equal(diagnostics.lastCleanup.dbMaintenance.vacuumed, true)
-  assert.ok(diagnostics.db.dbPath.endsWith('promptx.sqlite'))
-})

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

@@ -1,147 +0,0 @@
-import assert from 'node:assert/strict'
-import { spawn } from 'node:child_process'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import test from 'node:test'
-
-import { createManagedSpawnOptions, forceStopChildProcess } from './processControl.js'
-
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function waitFor(check, timeoutMs, errorMessage) {
-  const startedAt = Date.now()
-  while (Date.now() - startedAt < timeoutMs) {
-    if (await check()) {
-      return
-    }
-    await new Promise((resolve) => setTimeout(resolve, 50))
-  }
-
-  throw new Error(errorMessage)
-}
-
-test('forceStopChildProcess 会在宽限时间后结束忽略 SIGTERM 的子进程', async () => {
-  const child = spawn(
-    process.execPath,
-    ['-e', 'process.on("SIGTERM", () => {}); setInterval(() => {}, 1000)'],
-    createManagedSpawnOptions({
-      stdio: ['ignore', 'ignore', 'ignore'],
-    })
-  )
-
-  await new Promise((resolve) => {
-    child.once('spawn', resolve)
-  })
-
-  assert.equal(typeof child.pid, 'number')
-  forceStopChildProcess(child, { graceMs: 100 })
-
-  const closeResult = await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error('等待子进程退出超时'))
-    }, 5000)
-
-    child.once('close', (code, signal) => {
-      clearTimeout(timeout)
-      resolve({ code, signal })
-    })
-  })
-
-  assert.ok(closeResult.signal || closeResult.code !== null)
-})
-
-test('forceStopChildProcess 会结束脱离原进程组的后代进程', {
-  skip: process.platform === 'win32',
-}, async () => {
-  const fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-process-tree-'))
-  const detachedPidFile = path.join(fixtureDir, 'detached.pid')
-  const detachedExitFile = path.join(fixtureDir, 'detached.exit.json')
-  let detachedPid = 0
-  const detachedScript = [
-    "const fs = require('node:fs')",
-    `const detachedExitFile = ${JSON.stringify(detachedExitFile)}`,
-    "process.on('SIGTERM', () => {",
-    "  fs.writeFileSync(detachedExitFile, JSON.stringify({ reason: 'sigterm' }))",
-    "  process.exit(0)",
-    "})",
-    "setInterval(() => {}, 1000)",
-  ].join('\n')
-
-  const parentScript = [
-    "const fs = require('node:fs')",
-    "const { spawn } = require('node:child_process')",
-    `const detachedPidFile = ${JSON.stringify(detachedPidFile)}`,
-    `const detachedScript = ${JSON.stringify(detachedScript)}`,
-    "const detachedChild = spawn(process.execPath, ['-e', detachedScript], {",
-    "  detached: true,",
-    "  stdio: 'ignore',",
-    "})",
-    "fs.writeFileSync(detachedPidFile, String(detachedChild.pid))",
-    "detachedChild.unref()",
-    "process.on('SIGTERM', () => {})",
-    "setInterval(() => {}, 1000)",
-  ].join('\n')
-
-  const child = spawn(
-    process.execPath,
-    ['-e', parentScript],
-    createManagedSpawnOptions({
-      stdio: ['ignore', 'ignore', 'ignore'],
-    })
-  )
-
-  try {
-    await new Promise((resolve) => {
-      child.once('spawn', resolve)
-    })
-
-    await waitFor(() => fs.existsSync(detachedPidFile), 5000, '等待 detached.pid 超时')
-    detachedPid = Number(fs.readFileSync(detachedPidFile, 'utf8').trim()) || 0
-    assert.ok(detachedPid > 0)
-    assert.equal(isProcessAlive(detachedPid), true)
-
-    forceStopChildProcess(child, { graceMs: 100 })
-
-    const closeResult = await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error('等待父进程退出超时'))
-      }, 5000)
-
-      child.once('close', (code, signal) => {
-        clearTimeout(timeout)
-        resolve({ code, signal })
-      })
-    })
-
-    assert.ok(closeResult.signal || closeResult.code !== null)
-
-    await waitFor(() => !isProcessAlive(detachedPid), 5000, '等待后代进程退出超时')
-    await waitFor(() => fs.existsSync(detachedExitFile), 5000, '等待后代进程退出标记超时')
-
-    const exitPayload = JSON.parse(fs.readFileSync(detachedExitFile, 'utf8'))
-    assert.equal(exitPayload.reason, 'sigterm')
-  } finally {
-    if (detachedPid > 0 && isProcessAlive(detachedPid)) {
-      try {
-        process.kill(-detachedPid, 'SIGKILL')
-      } catch {
-        // Ignore cleanup failures for already-exited processes.
-      }
-      try {
-        process.kill(detachedPid, 'SIGKILL')
-      } catch {
-        // Ignore cleanup failures for already-exited processes.
-      }
-    }
-
-    fs.rmSync(fixtureDir, { recursive: true, force: true })
-  }
-})