mirror of
https://github.com/Ark0N/Codeman.git
synced 2026-09-30 20:49:41 +02:00
arkonandClaude Opus 4.8
458fb81cbe
Point 1 of the v1.0 lock-in: commit to a stable HTTP API (the cleanest, fullest form).
Core (centralized):
- Every JSON /api response now uses ONE envelope via a Fastify preSerialization hook (src/web/server.ts): success -> { success:true, data:<payload> }; error -> { success:false, error, errorCode } with a conventional HTTP status. Non-JSON routes (file-raw, tail-file SSE, download, screenshots, /q redirect, WS) are skipped.
- Error-code -> HTTP status is a single source of truth (httpStatusForErrorCode in src/types/api.ts): 400/401/404/409/422/429/500. Expanded ApiErrorCode (added UNAUTHORIZED, CONFLICT, RATE_LIMITED). Errors are no longer HTTP 200.
- Versioned alias: /api/v1/* rewrites to /api/* (rewriteApiV1Url), so external clients pin to a stable surface while the bundled UI keeps using /api/*.
- Handlers stripped of manual 'success:true' (50 across 14 route files) so they return bare payloads the hook wraps uniformly; fixed the mux DELETE {success:<bool>} envelope collision (-> {killed}).
Frontend (48 call sites across 10 files):
- _apiJson() auto-unwraps { success:true, data } -> data (null on error), so most bare-shape readers are transparent. Raw-fetch sites relocate payload reads under .data; success/res.ok/error checks unchanged.
Docs: new docs/api-reference.md (envelope, status table, error codes, /api/v1, SSE); versioning-policy.md flipped — the HTTP/SSE API is now part of the stable, SemVer-covered surface.
Verification: full unit/route suite green (2680 passed) incl. ~166 updated assertions across 24 test files; typecheck/lint/format/frontend-syntax clean; a headless-chromium smoke loaded the migrated UI and drove the panels with 0 console/page errors; /api/status and /api/v1/status confirmed returning the uniform envelope live.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
1031 lines
36 KiB
TypeScript
1031 lines
36 KiB
TypeScript
/**
|
|
* @fileoverview Integration tests for Ralph/Todo tracking
|
|
*
|
|
* Tests the complete Ralph Wiggum loop and Todo tracking functionality
|
|
* through the API endpoints. These tests verify:
|
|
* - Session lifecycle (create, list, delete)
|
|
* - Ralph loop state tracking and updates
|
|
* - Todo item detection and management
|
|
* - Ralph configuration via API
|
|
*
|
|
* Test port: 3125
|
|
*/
|
|
|
|
import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
|
|
import { WebServer } from '../src/web/server.js';
|
|
import { existsSync, rmSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import { homedir } from 'node:os';
|
|
|
|
const TEST_PORT = 3125;
|
|
const CASES_DIR = join(homedir(), 'codeman-cases');
|
|
|
|
describe('Ralph Integration Tests', () => {
|
|
let server: WebServer;
|
|
let baseUrl: string;
|
|
const createdCases: string[] = [];
|
|
const createdSessions: string[] = [];
|
|
|
|
beforeAll(async () => {
|
|
server = new WebServer(TEST_PORT, false, true);
|
|
await server.start();
|
|
baseUrl = `http://localhost:${TEST_PORT}`;
|
|
});
|
|
|
|
afterEach(() => {
|
|
// Clean up cases created during this test
|
|
while (createdCases.length > 0) {
|
|
const caseName = createdCases.pop()!;
|
|
const casePath = join(CASES_DIR, caseName);
|
|
if (existsSync(casePath)) {
|
|
rmSync(casePath, { recursive: true, force: true });
|
|
}
|
|
}
|
|
});
|
|
|
|
afterAll(async () => {
|
|
// Cleanup sessions
|
|
for (const sessionId of createdSessions) {
|
|
try {
|
|
await fetch(`${baseUrl}/api/sessions/${sessionId}`, { method: 'DELETE' });
|
|
} catch {}
|
|
}
|
|
await server.stop();
|
|
}, 60000);
|
|
|
|
// ========== Session Lifecycle Tests ==========
|
|
|
|
describe('Session Lifecycle', () => {
|
|
it('should list sessions as an array', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(Array.isArray(data.data)).toBe(true);
|
|
});
|
|
|
|
it('should create a new session via quick-start', async () => {
|
|
const caseName = `ralph-test-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const res = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(data.success).toBe(true);
|
|
expect(data.data.sessionId).toBeDefined();
|
|
createdSessions.push(data.data.sessionId);
|
|
});
|
|
|
|
it('should get session details by ID', async () => {
|
|
const caseName = `session-detail-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
// Create session first
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
// Get session details
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.data.id).toBe(createData.data.sessionId);
|
|
expect(data.data.workingDir).toContain(caseName);
|
|
});
|
|
|
|
it('should return error for non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/non-existent-id`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
|
|
it('should delete a session', async () => {
|
|
const caseName = `delete-test-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
// Create session
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
const sessionId = createData.data.sessionId;
|
|
|
|
// Delete session
|
|
const deleteRes = await fetch(`${baseUrl}/api/sessions/${sessionId}`, {
|
|
method: 'DELETE',
|
|
});
|
|
const deleteData = await deleteRes.json();
|
|
|
|
expect(deleteRes.status).toBe(200);
|
|
expect(deleteData.success).toBe(true);
|
|
|
|
// Verify session is gone
|
|
const getRes = await fetch(`${baseUrl}/api/sessions/${sessionId}`);
|
|
const getData = await getRes.json();
|
|
expect(getRes.status).toBe(404);
|
|
expect(getData.error).toContain('not found');
|
|
});
|
|
|
|
it('should create shell session', async () => {
|
|
const caseName = `shell-test-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const res = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName, mode: 'shell' }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(data.success).toBe(true);
|
|
expect(data.data.sessionId).toBeDefined();
|
|
createdSessions.push(data.data.sessionId);
|
|
|
|
// Verify mode
|
|
const sessionRes = await fetch(`${baseUrl}/api/sessions/${data.data.sessionId}`);
|
|
const sessionData = await sessionRes.json();
|
|
expect(sessionData.data.mode).toBe('shell');
|
|
});
|
|
});
|
|
|
|
// ========== Ralph State API Tests ==========
|
|
|
|
describe('Ralph State API', () => {
|
|
it('should get ralph state for session', async () => {
|
|
const caseName = `ralph-state-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-state`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
// API returns { success: true, data: { loop, todos, todoStats } }
|
|
expect(data.data).toBeDefined();
|
|
expect(data.data.loop).toBeDefined();
|
|
expect(data.data.todos).toBeDefined();
|
|
});
|
|
|
|
it('should return error for ralph state of non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/ralph-state`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.error).toContain('not found');
|
|
});
|
|
});
|
|
|
|
// ========== Cases API Tests ==========
|
|
|
|
describe('Cases API', () => {
|
|
it('should list cases', async () => {
|
|
const res = await fetch(`${baseUrl}/api/cases`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(Array.isArray(data.data)).toBe(true);
|
|
});
|
|
|
|
it('should create a new case', async () => {
|
|
const caseName = `new-case-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const res = await fetch(`${baseUrl}/api/cases`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ name: caseName }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
expect(data.data.case.name).toBe(caseName);
|
|
});
|
|
|
|
it('should reject duplicate case name', async () => {
|
|
const caseName = `dup-case-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
// Create first
|
|
await fetch(`${baseUrl}/api/cases`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ name: caseName }),
|
|
});
|
|
|
|
// Try to create duplicate
|
|
const res = await fetch(`${baseUrl}/api/cases`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ name: caseName }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(409);
|
|
expect(data.success).toBe(false);
|
|
expect(data.error).toContain('already exists');
|
|
});
|
|
|
|
it('should get case by name', async () => {
|
|
const caseName = `get-case-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
// Create case
|
|
await fetch(`${baseUrl}/api/cases`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ name: caseName }),
|
|
});
|
|
|
|
// Get case
|
|
const res = await fetch(`${baseUrl}/api/cases/${caseName}`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.data.name).toBe(caseName);
|
|
expect(data.data.path).toContain(caseName);
|
|
});
|
|
|
|
it('should return error for non-existent case', async () => {
|
|
const res = await fetch(`${baseUrl}/api/cases/non-existent-case-12345`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.error).toBe('Case not found');
|
|
});
|
|
});
|
|
|
|
// ========== Status API Tests ==========
|
|
|
|
describe('Status API', () => {
|
|
it('should return app status', async () => {
|
|
const res = await fetch(`${baseUrl}/api/status`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.data.sessions).toBeDefined();
|
|
expect(data.data.scheduledRuns).toBeDefined();
|
|
expect(data.data.respawnStatus).toBeDefined();
|
|
expect(data.data.timestamp).toBeDefined();
|
|
});
|
|
|
|
it('should include sessions array in status', async () => {
|
|
const res = await fetch(`${baseUrl}/api/status`);
|
|
const data = await res.json();
|
|
|
|
expect(Array.isArray(data.data.sessions)).toBe(true);
|
|
expect(typeof data.data.timestamp).toBe('number');
|
|
});
|
|
});
|
|
|
|
// ========== Mux Sessions API Tests ==========
|
|
|
|
describe('Mux Sessions API', () => {
|
|
it('should return sessions object with array', async () => {
|
|
const res = await fetch(`${baseUrl}/api/mux-sessions`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.data.sessions).toBeDefined();
|
|
expect(Array.isArray(data.data.sessions)).toBe(true);
|
|
expect(typeof data.data.muxAvailable).toBe('boolean');
|
|
});
|
|
});
|
|
|
|
// ========== Session Input Tests ==========
|
|
|
|
describe('Session Input', () => {
|
|
it('should send input to session', async () => {
|
|
const caseName = `input-test-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/input`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ input: 'test input' }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
|
|
it('should reject null input', async () => {
|
|
const caseName = `input-null-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/input`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ input: null }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(400);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('INVALID_INPUT');
|
|
});
|
|
|
|
it('should return error for input to non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/input`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ input: 'test' }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
});
|
|
|
|
// ========== Session Resize Tests ==========
|
|
|
|
describe('Session Resize', () => {
|
|
it('should resize session terminal', async () => {
|
|
const caseName = `resize-test-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
// Wait for session to be ready
|
|
await new Promise((r) => setTimeout(r, 200));
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/resize`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ cols: 120, rows: 40 }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
|
|
it('should reject invalid resize dimensions', async () => {
|
|
const caseName = `resize-invalid-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
// Wait for session to be ready
|
|
await new Promise((r) => setTimeout(r, 200));
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/resize`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ cols: -1, rows: 40 }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(400);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('INVALID_INPUT');
|
|
});
|
|
});
|
|
|
|
// ========== Auto-Compact/Clear Config Tests ==========
|
|
|
|
describe('Auto-Compact Config', () => {
|
|
it('should configure auto-compact for session', async () => {
|
|
const caseName = `auto-compact-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/auto-compact`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true, threshold: 100000 }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
|
|
it('should return error for auto-compact of non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/auto-compact`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
|
|
it('should reject invalid threshold', async () => {
|
|
const caseName = `auto-compact-invalid-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/auto-compact`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true, threshold: -100 }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(400);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('INVALID_INPUT');
|
|
});
|
|
});
|
|
|
|
describe('Auto-Clear Config', () => {
|
|
it('should configure auto-clear for session', async () => {
|
|
const caseName = `auto-clear-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/auto-clear`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true, threshold: 150000 }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
|
|
it('should return error for auto-clear of non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/auto-clear`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
|
|
it('should reject invalid threshold for auto-clear', async () => {
|
|
const caseName = `auto-clear-invalid-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/auto-clear`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true, threshold: -50 }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(400);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('INVALID_INPUT');
|
|
});
|
|
});
|
|
|
|
// ========== Ralph Config API Tests ==========
|
|
|
|
describe('Ralph Config API', () => {
|
|
it('should configure ralph tracking for session', async () => {
|
|
const caseName = `ralph-config-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
|
|
it('should reset ralph state via config', async () => {
|
|
const caseName = `ralph-reset-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ reset: true }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
|
|
it('should return error for ralph-config of non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
|
|
it('should perform full ralph reset via config', async () => {
|
|
const caseName = `ralph-full-reset-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ reset: 'full' }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
|
|
it('should set completion phrase via ralph-config', async () => {
|
|
const caseName = `ralph-phrase-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true, completionPhrase: 'DONE' }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
|
|
// Verify the state was updated
|
|
const stateRes = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-state`);
|
|
const stateData = await stateRes.json();
|
|
|
|
expect(stateData.success).toBe(true);
|
|
expect(stateData.data.loop.enabled).toBe(true);
|
|
});
|
|
|
|
it('should disable auto-enable via ralph-config', async () => {
|
|
const caseName = `ralph-auto-disable-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ disableAutoEnable: true }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
});
|
|
});
|
|
|
|
// ========== Ralph State and Todo Tracking Tests ==========
|
|
|
|
describe('Ralph State Tracking', () => {
|
|
it('should return initial ralph state with empty todos', async () => {
|
|
const caseName = `ralph-initial-state-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-state`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
expect(data.data.loop).toBeDefined();
|
|
expect(data.data.todos).toBeDefined();
|
|
expect(Array.isArray(data.data.todos)).toBe(true);
|
|
expect(data.data.todoStats).toBeDefined();
|
|
});
|
|
|
|
it('should track loop state after enabling', async () => {
|
|
const caseName = `ralph-track-loop-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
// Enable ralph tracking
|
|
await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true, completionPhrase: 'TASK_DONE' }),
|
|
});
|
|
|
|
// Check state
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-state`);
|
|
const data = await res.json();
|
|
|
|
expect(data.success).toBe(true);
|
|
expect(data.data.loop.enabled).toBe(true);
|
|
expect(data.data.loop.completionPhrase).toBe('TASK_DONE');
|
|
});
|
|
|
|
it('should clear todos on reset', async () => {
|
|
const caseName = `ralph-clear-todos-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
// Enable first
|
|
await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true }),
|
|
});
|
|
|
|
// Then reset
|
|
const resetRes = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ reset: true }),
|
|
});
|
|
const resetData = await resetRes.json();
|
|
|
|
expect(resetData.success).toBe(true);
|
|
|
|
// Check that todos are cleared
|
|
const stateRes = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-state`);
|
|
const stateData = await stateRes.json();
|
|
|
|
expect(stateData.success).toBe(true);
|
|
expect(stateData.data.todos).toEqual([]);
|
|
});
|
|
|
|
it('should preserve enabled status on soft reset', async () => {
|
|
const caseName = `ralph-soft-reset-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
// Enable tracking
|
|
await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true }),
|
|
});
|
|
|
|
// Soft reset (keep enabled)
|
|
await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ reset: true }),
|
|
});
|
|
|
|
// Check state
|
|
const stateRes = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-state`);
|
|
const stateData = await stateRes.json();
|
|
|
|
expect(stateData.success).toBe(true);
|
|
expect(stateData.data.loop.enabled).toBe(true);
|
|
});
|
|
|
|
it('should disable tracking on full reset', async () => {
|
|
const caseName = `ralph-full-reset-disable-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
// Enable tracking
|
|
await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ enabled: true }),
|
|
});
|
|
|
|
// Full reset
|
|
await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-config`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ reset: 'full' }),
|
|
});
|
|
|
|
// Check state
|
|
const stateRes = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/ralph-state`);
|
|
const stateData = await stateRes.json();
|
|
|
|
expect(stateData.success).toBe(true);
|
|
expect(stateData.data.loop.enabled).toBe(false);
|
|
});
|
|
});
|
|
|
|
// ========== Respawn Controller Tests ==========
|
|
|
|
describe('Respawn Controller API', () => {
|
|
it('should return no respawn status for new session', async () => {
|
|
const caseName = `respawn-new-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/respawn`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.data.enabled).toBe(false);
|
|
});
|
|
|
|
it('should return error for respawn start on non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/respawn/start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({}),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
|
|
it('should return error for respawn stop without controller', async () => {
|
|
const caseName = `respawn-stop-none-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/respawn/stop`, {
|
|
method: 'POST',
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
|
|
it('should save respawn config as pre-config without controller', async () => {
|
|
const caseName = `respawn-config-none-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/respawn/config`, {
|
|
method: 'PUT',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ idleTimeoutMs: 10000 }),
|
|
});
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
expect(data.data.config.idleTimeoutMs).toBe(10000);
|
|
});
|
|
});
|
|
|
|
// ========== Session Output and Terminal Tests ==========
|
|
|
|
describe('Session Output API', () => {
|
|
it('should get session output', async () => {
|
|
const caseName = `output-test-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/output`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.success).toBe(true);
|
|
expect(data.data).toBeDefined();
|
|
expect(data.data.textOutput).toBeDefined();
|
|
expect(data.data.messages).toBeDefined();
|
|
});
|
|
|
|
it('should return error for output of non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/output`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
|
|
it('should get session terminal buffer', async () => {
|
|
const caseName = `terminal-test-${Date.now()}`;
|
|
createdCases.push(caseName);
|
|
|
|
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ caseName }),
|
|
});
|
|
const createData = await createRes.json();
|
|
expect(createData.success).toBe(true);
|
|
createdSessions.push(createData.data.sessionId);
|
|
|
|
const res = await fetch(`${baseUrl}/api/sessions/${createData.data.sessionId}/terminal`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(data.data.terminalBuffer).toBeDefined();
|
|
expect(data.data.status).toBeDefined();
|
|
});
|
|
|
|
it('should return error for terminal of non-existent session', async () => {
|
|
const res = await fetch(`${baseUrl}/api/sessions/fake-session/terminal`);
|
|
const data = await res.json();
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(data.success).toBe(false);
|
|
expect(data.errorCode).toBe('NOT_FOUND');
|
|
});
|
|
});
|
|
});
|