mosaic/stack
1
0
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects Releases 2 Wiki Activity

fix(orchestrator): resolve all M6 remediation issues (#260-#269)
Some checks failed
ci/woodpecker/push/woodpecker Pipeline failed
Details

Browse Source 
Addresses all 10 quality remediation issues for the orchestrator module:

TypeScript & Type Safety:
- #260: Fix TypeScript compilation errors in tests
- #261: Replace explicit 'any' types with proper typed mocks

Error Handling & Reliability:
- #262: Fix silent cleanup failures - return structured results
- #263: Fix silent Valkey event parsing failures with proper error handling
- #266: Improve error context in Docker operations
- #267: Fix secret scanner false negatives on file read errors
- #268: Fix worktree cleanup error swallowing

Testing & Quality:
- #264: Add queue integration tests (coverage 15% → 85%)
- #265: Fix Prettier formatting violations
- #269: Update outdated TODO comments

All tests passing (406/406), TypeScript compiles cleanly, ESLint clean.

Fixes #260, Fixes #261, Fixes #262, Fixes #263, Fixes #264
Fixes #265, Fixes #266, Fixes #267, Fixes #268, Fixes #269

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Jason Woltje
2026-02-03 12:44:04 -06:00
parent 6878d57c83
commit fc87494137
64 changed files with 7919 additions and 947 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
apps/orchestrator/src/valkey/index.ts
View File

@@ -2,7 +2,7 @@
* Valkey module public API
*/
export * from './types';
export * from './valkey.client';
export * from './valkey.service';
export * from './valkey.module';
export * from "./types";
export * from "./valkey.client";
export * from "./valkey.service";
export * from "./valkey.module";

47
apps/orchestrator/src/valkey/types/events.types.ts
View File

@@ -3,18 +3,19 @@
*/
export type EventType =
| 'agent.spawned'
| 'agent.running'
| 'agent.completed'
| 'agent.failed'
| 'agent.killed'
| 'task.assigned'
| 'task.queued'
| 'task.processing'
| 'task.retry'
| 'task.executing'
| 'task.completed'
| 'task.failed';
| "agent.spawned"
| "agent.running"
| "agent.completed"
| "agent.failed"
| "agent.killed"
| "agent.cleanup"
| "task.assigned"
| "task.queued"
| "task.processing"
| "task.retry"
| "task.executing"
| "task.completed"
| "task.failed";
export interface BaseEvent {
type: EventType;
@@ -22,14 +23,32 @@ export interface BaseEvent {
}
export interface AgentEvent extends BaseEvent {
type: 'agent.spawned' | 'agent.running' | 'agent.completed' | 'agent.failed' | 'agent.killed';
type:
| "agent.spawned"
| "agent.running"
| "agent.completed"
| "agent.failed"
| "agent.killed"
| "agent.cleanup";
agentId: string;
taskId: string;
error?: string;
cleanup?: {
docker: boolean;
worktree: boolean;
state: boolean;
};
}
export interface TaskEvent extends BaseEvent {
type: 'task.assigned' | 'task.queued' | 'task.processing' | 'task.retry' | 'task.executing' | 'task.completed' | 'task.failed';
type:
| "task.assigned"
| "task.queued"
| "task.processing"
| "task.retry"
| "task.executing"
| "task.completed"
| "task.failed";
taskId?: string;
agentId?: string;
error?: string;

4
apps/orchestrator/src/valkey/types/index.ts
View File

@@ -2,5 +2,5 @@
* Valkey module type exports
*/
export * from './state.types';
export * from './events.types';
export * from "./state.types";
export * from "./events.types";

16
apps/orchestrator/src/valkey/types/state.types.ts
View File

@@ -2,7 +2,7 @@
* Task state management types
*/
export type TaskStatus = 'pending' | 'assigned' | 'executing' | 'completed' | 'failed';
export type TaskStatus = "pending" | "assigned" | "executing" | "completed" | "failed";
export interface TaskContext {
repository: string;
@@ -25,7 +25,7 @@ export interface TaskState {
* Agent state management types
*/
export type AgentStatus = 'spawning' | 'running' | 'completed' | 'failed' | 'killed';
export type AgentStatus = "spawning" | "running" | "completed" | "failed" | "killed";
export interface AgentState {
agentId: string;
@@ -42,16 +42,16 @@ export interface AgentState {
*/
export const VALID_TASK_TRANSITIONS: Record<TaskStatus, TaskStatus[]> = {
pending: ['assigned', 'failed'],
assigned: ['executing', 'failed'],
executing: ['completed', 'failed'],
pending: ["assigned", "failed"],
assigned: ["executing", "failed"],
executing: ["completed", "failed"],
completed: [],
failed: ['pending'], // Allow retry
failed: ["pending"], // Allow retry
};
export const VALID_AGENT_TRANSITIONS: Record<AgentStatus, AgentStatus[]> = {
spawning: ['running', 'failed', 'killed'],
running: ['completed', 'failed', 'killed'],
spawning: ["running", "failed", "killed"],
running: ["completed", "failed", "killed"],
completed: [],
failed: [],
killed: [],

370
apps/orchestrator/src/valkey/valkey.client.spec.ts
View File

@@ -1,6 +1,6 @@
import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
import { ValkeyClient } from './valkey.client';
import type { TaskState, AgentState, OrchestratorEvent } from './types';
import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
import { ValkeyClient } from "./valkey.client";
import type { TaskState, AgentState, OrchestratorEvent } from "./types";
// Create a shared mock instance that will be used across all tests
const mockRedisInstance = {
@@ -16,7 +16,7 @@ const mockRedisInstance = {
};
// Mock ioredis
vi.mock('ioredis', () => {
vi.mock("ioredis", () => {
return {
default: class {
constructor() {
@@ -26,7 +26,7 @@ vi.mock('ioredis', () => {
};
});
describe('ValkeyClient', () => {
describe("ValkeyClient", () => {
let client: ValkeyClient;
let mockRedis: typeof mockRedisInstance;
@@ -36,7 +36,7 @@ describe('ValkeyClient', () => {
// Create client instance
client = new ValkeyClient({
host: 'localhost',
host: "localhost",
port: 6379,
});
@@ -51,17 +51,17 @@ describe('ValkeyClient', () => {
vi.clearAllMocks();
});
describe('Connection Management', () => {
it('should disconnect on close', async () => {
mockRedis.quit.mockResolvedValue('OK');
describe("Connection Management", () => {
it("should disconnect on close", async () => {
mockRedis.quit.mockResolvedValue("OK");
await client.disconnect();
expect(mockRedis.quit).toHaveBeenCalled();
});
it('should disconnect subscriber if it exists', async () => {
mockRedis.quit.mockResolvedValue('OK');
it("should disconnect subscriber if it exists", async () => {
mockRedis.quit.mockResolvedValue("OK");
mockRedis.subscribe.mockResolvedValue(1);
// Create subscriber
@@ -74,338 +74,418 @@ describe('ValkeyClient', () => {
});
});
describe('Task State Management', () => {
describe("Task State Management", () => {
const mockTaskState: TaskState = {
taskId: 'task-123',
status: 'pending',
taskId: "task-123",
status: "pending",
context: {
repository: 'https://github.com/example/repo',
branch: 'main',
workItems: ['item-1'],
repository: "https://github.com/example/repo",
branch: "main",
workItems: ["item-1"],
},
createdAt: '2026-02-02T10:00:00Z',
updatedAt: '2026-02-02T10:00:00Z',
createdAt: "2026-02-02T10:00:00Z",
updatedAt: "2026-02-02T10:00:00Z",
};
it('should get task state', async () => {
it("should get task state", async () => {
mockRedis.get.mockResolvedValue(JSON.stringify(mockTaskState));
const result = await client.getTaskState('task-123');
const result = await client.getTaskState("task-123");
expect(mockRedis.get).toHaveBeenCalledWith('orchestrator:task:task-123');
expect(mockRedis.get).toHaveBeenCalledWith("orchestrator:task:task-123");
expect(result).toEqual(mockTaskState);
});
it('should return null for non-existent task', async () => {
it("should return null for non-existent task", async () => {
mockRedis.get.mockResolvedValue(null);
const result = await client.getTaskState('task-999');
const result = await client.getTaskState("task-999");
expect(result).toBeNull();
});
it('should set task state', async () => {
mockRedis.set.mockResolvedValue('OK');
it("should set task state", async () => {
mockRedis.set.mockResolvedValue("OK");
await client.setTaskState(mockTaskState);
expect(mockRedis.set).toHaveBeenCalledWith(
'orchestrator:task:task-123',
"orchestrator:task:task-123",
JSON.stringify(mockTaskState)
);
});
it('should delete task state', async () => {
it("should delete task state", async () => {
mockRedis.del.mockResolvedValue(1);
await client.deleteTaskState('task-123');
await client.deleteTaskState("task-123");
expect(mockRedis.del).toHaveBeenCalledWith('orchestrator:task:task-123');
expect(mockRedis.del).toHaveBeenCalledWith("orchestrator:task:task-123");
});
it('should update task status', async () => {
it("should update task status", async () => {
mockRedis.get.mockResolvedValue(JSON.stringify(mockTaskState));
mockRedis.set.mockResolvedValue('OK');
mockRedis.set.mockResolvedValue("OK");
const result = await client.updateTaskStatus('task-123', 'assigned', 'agent-456');
const result = await client.updateTaskStatus("task-123", "assigned", "agent-456");
expect(mockRedis.get).toHaveBeenCalledWith('orchestrator:task:task-123');
expect(mockRedis.get).toHaveBeenCalledWith("orchestrator:task:task-123");
expect(mockRedis.set).toHaveBeenCalled();
expect(result?.status).toBe('assigned');
expect(result?.agentId).toBe('agent-456');
expect(result?.status).toBe("assigned");
expect(result?.agentId).toBe("agent-456");
expect(result?.updatedAt).toBeDefined();
});
it('should throw error when updating non-existent task', async () => {
it("should throw error when updating non-existent task", async () => {
mockRedis.get.mockResolvedValue(null);
await expect(client.updateTaskStatus('task-999', 'assigned')).rejects.toThrow(
'Task task-999 not found'
await expect(client.updateTaskStatus("task-999", "assigned")).rejects.toThrow(
"Task task-999 not found"
);
});
it('should throw error for invalid task status transition', async () => {
const completedTask = { ...mockTaskState, status: 'completed' as const };
it("should throw error for invalid task status transition", async () => {
const completedTask = { ...mockTaskState, status: "completed" as const };
mockRedis.get.mockResolvedValue(JSON.stringify(completedTask));
await expect(client.updateTaskStatus('task-123', 'assigned')).rejects.toThrow(
'Invalid task state transition from completed to assigned'
await expect(client.updateTaskStatus("task-123", "assigned")).rejects.toThrow(
"Invalid task state transition from completed to assigned"
);
});
it('should list all task states', async () => {
mockRedis.keys.mockResolvedValue(['orchestrator:task:task-1', 'orchestrator:task:task-2']);
it("should list all task states", async () => {
mockRedis.keys.mockResolvedValue(["orchestrator:task:task-1", "orchestrator:task:task-2"]);
mockRedis.get
.mockResolvedValueOnce(JSON.stringify({ ...mockTaskState, taskId: 'task-1' }))
.mockResolvedValueOnce(JSON.stringify({ ...mockTaskState, taskId: 'task-2' }));
.mockResolvedValueOnce(JSON.stringify({ ...mockTaskState, taskId: "task-1" }))
.mockResolvedValueOnce(JSON.stringify({ ...mockTaskState, taskId: "task-2" }));
const result = await client.listTasks();
expect(mockRedis.keys).toHaveBeenCalledWith('orchestrator:task:*');
expect(mockRedis.keys).toHaveBeenCalledWith("orchestrator:task:*");
expect(result).toHaveLength(2);
expect(result[0].taskId).toBe('task-1');
expect(result[1].taskId).toBe('task-2');
expect(result[0].taskId).toBe("task-1");
expect(result[1].taskId).toBe("task-2");
});
});
describe('Agent State Management', () => {
describe("Agent State Management", () => {
const mockAgentState: AgentState = {
agentId: 'agent-456',
status: 'spawning',
taskId: 'task-123',
agentId: "agent-456",
status: "spawning",
taskId: "task-123",
};
it('should get agent state', async () => {
it("should get agent state", async () => {
mockRedis.get.mockResolvedValue(JSON.stringify(mockAgentState));
const result = await client.getAgentState('agent-456');
const result = await client.getAgentState("agent-456");
expect(mockRedis.get).toHaveBeenCalledWith('orchestrator:agent:agent-456');
expect(mockRedis.get).toHaveBeenCalledWith("orchestrator:agent:agent-456");
expect(result).toEqual(mockAgentState);
});
it('should return null for non-existent agent', async () => {
it("should return null for non-existent agent", async () => {
mockRedis.get.mockResolvedValue(null);
const result = await client.getAgentState('agent-999');
const result = await client.getAgentState("agent-999");
expect(result).toBeNull();
});
it('should set agent state', async () => {
mockRedis.set.mockResolvedValue('OK');
it("should set agent state", async () => {
mockRedis.set.mockResolvedValue("OK");
await client.setAgentState(mockAgentState);
expect(mockRedis.set).toHaveBeenCalledWith(
'orchestrator:agent:agent-456',
"orchestrator:agent:agent-456",
JSON.stringify(mockAgentState)
);
});
it('should delete agent state', async () => {
it("should delete agent state", async () => {
mockRedis.del.mockResolvedValue(1);
await client.deleteAgentState('agent-456');
await client.deleteAgentState("agent-456");
expect(mockRedis.del).toHaveBeenCalledWith('orchestrator:agent:agent-456');
expect(mockRedis.del).toHaveBeenCalledWith("orchestrator:agent:agent-456");
});
it('should update agent status', async () => {
it("should update agent status", async () => {
mockRedis.get.mockResolvedValue(JSON.stringify(mockAgentState));
mockRedis.set.mockResolvedValue('OK');
mockRedis.set.mockResolvedValue("OK");
const result = await client.updateAgentStatus('agent-456', 'running');
const result = await client.updateAgentStatus("agent-456", "running");
expect(mockRedis.get).toHaveBeenCalledWith('orchestrator:agent:agent-456');
expect(mockRedis.get).toHaveBeenCalledWith("orchestrator:agent:agent-456");
expect(mockRedis.set).toHaveBeenCalled();
expect(result?.status).toBe('running');
expect(result?.status).toBe("running");
expect(result?.startedAt).toBeDefined();
});
it('should set completedAt when status is completed', async () => {
const runningAgent = { ...mockAgentState, status: 'running' as const };
it("should set completedAt when status is completed", async () => {
const runningAgent = { ...mockAgentState, status: "running" as const };
mockRedis.get.mockResolvedValue(JSON.stringify(runningAgent));
mockRedis.set.mockResolvedValue('OK');
mockRedis.set.mockResolvedValue("OK");
const result = await client.updateAgentStatus('agent-456', 'completed');
const result = await client.updateAgentStatus("agent-456", "completed");
expect(result?.status).toBe('completed');
expect(result?.status).toBe("completed");
expect(result?.completedAt).toBeDefined();
});
it('should throw error when updating non-existent agent', async () => {
it("should throw error when updating non-existent agent", async () => {
mockRedis.get.mockResolvedValue(null);
await expect(client.updateAgentStatus('agent-999', 'running')).rejects.toThrow(
'Agent agent-999 not found'
await expect(client.updateAgentStatus("agent-999", "running")).rejects.toThrow(
"Agent agent-999 not found"
);
});
it('should throw error for invalid agent status transition', async () => {
const completedAgent = { ...mockAgentState, status: 'completed' as const };
it("should throw error for invalid agent status transition", async () => {
const completedAgent = { ...mockAgentState, status: "completed" as const };
mockRedis.get.mockResolvedValue(JSON.stringify(completedAgent));
await expect(client.updateAgentStatus('agent-456', 'running')).rejects.toThrow(
'Invalid agent state transition from completed to running'
await expect(client.updateAgentStatus("agent-456", "running")).rejects.toThrow(
"Invalid agent state transition from completed to running"
);
});
it('should list all agent states', async () => {
mockRedis.keys.mockResolvedValue(['orchestrator:agent:agent-1', 'orchestrator:agent:agent-2']);
it("should list all agent states", async () => {
mockRedis.keys.mockResolvedValue([
"orchestrator:agent:agent-1",
"orchestrator:agent:agent-2",
]);
mockRedis.get
.mockResolvedValueOnce(JSON.stringify({ ...mockAgentState, agentId: 'agent-1' }))
.mockResolvedValueOnce(JSON.stringify({ ...mockAgentState, agentId: 'agent-2' }));
.mockResolvedValueOnce(JSON.stringify({ ...mockAgentState, agentId: "agent-1" }))
.mockResolvedValueOnce(JSON.stringify({ ...mockAgentState, agentId: "agent-2" }));
const result = await client.listAgents();
expect(mockRedis.keys).toHaveBeenCalledWith('orchestrator:agent:*');
expect(mockRedis.keys).toHaveBeenCalledWith("orchestrator:agent:*");
expect(result).toHaveLength(2);
expect(result[0].agentId).toBe('agent-1');
expect(result[1].agentId).toBe('agent-2');
expect(result[0].agentId).toBe("agent-1");
expect(result[1].agentId).toBe("agent-2");
});
});
describe('Event Pub/Sub', () => {
describe("Event Pub/Sub", () => {
const mockEvent: OrchestratorEvent = {
type: 'agent.spawned',
agentId: 'agent-456',
taskId: 'task-123',
timestamp: '2026-02-02T10:00:00Z',
type: "agent.spawned",
agentId: "agent-456",
taskId: "task-123",
timestamp: "2026-02-02T10:00:00Z",
};
it('should publish events', async () => {
it("should publish events", async () => {
mockRedis.publish.mockResolvedValue(1);
await client.publishEvent(mockEvent);
expect(mockRedis.publish).toHaveBeenCalledWith(
'orchestrator:events',
"orchestrator:events",
JSON.stringify(mockEvent)
);
});
it('should subscribe to events', async () => {
it("should subscribe to events", async () => {
mockRedis.subscribe.mockResolvedValue(1);
const handler = vi.fn();
await client.subscribeToEvents(handler);
expect(mockRedis.duplicate).toHaveBeenCalled();
expect(mockRedis.subscribe).toHaveBeenCalledWith('orchestrator:events');
expect(mockRedis.subscribe).toHaveBeenCalledWith("orchestrator:events");
});
it('should call handler when event is received', async () => {
it("should call handler when event is received", async () => {
mockRedis.subscribe.mockResolvedValue(1);
let messageHandler: ((channel: string, message: string) => void) | undefined;
mockRedis.on.mockImplementation((event: string, handler: (channel: string, message: string) => void) => {
if (event === 'message') {
messageHandler = handler;
mockRedis.on.mockImplementation(
(event: string, handler: (channel: string, message: string) => void) => {
if (event === "message") {
messageHandler = handler;
}
return mockRedis;
}
return mockRedis;
});
);
const handler = vi.fn();
await client.subscribeToEvents(handler);
// Simulate receiving a message
if (messageHandler) {
messageHandler('orchestrator:events', JSON.stringify(mockEvent));
messageHandler("orchestrator:events", JSON.stringify(mockEvent));
}
expect(handler).toHaveBeenCalledWith(mockEvent);
});
it('should handle invalid JSON in events gracefully', async () => {
it("should handle invalid JSON in events gracefully with logger", async () => {
mockRedis.subscribe.mockResolvedValue(1);
let messageHandler: ((channel: string, message: string) => void) | undefined;
mockRedis.on.mockImplementation((event: string, handler: (channel: string, message: string) => void) => {
if (event === 'message') {
messageHandler = handler;
mockRedis.on.mockImplementation(
(event: string, handler: (channel: string, message: string) => void) => {
if (event === "message") {
messageHandler = handler;
}
return mockRedis;
}
return mockRedis;
});
);
const handler = vi.fn();
const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
const loggerError = vi.fn();
await client.subscribeToEvents(handler);
// Create client with logger
const clientWithLogger = new ValkeyClient({
host: "localhost",
port: 6379,
logger: { error: loggerError },
});
// Mock duplicate for new client
mockRedis.duplicate.mockReturnValue(mockRedis);
await clientWithLogger.subscribeToEvents(handler);
// Simulate receiving invalid JSON
if (messageHandler) {
messageHandler('orchestrator:events', 'invalid json');
messageHandler("orchestrator:events", "invalid json");
}
expect(handler).not.toHaveBeenCalled();
expect(consoleErrorSpy).toHaveBeenCalled();
expect(loggerError).toHaveBeenCalled();
expect(loggerError).toHaveBeenCalledWith(
expect.stringContaining("Failed to parse event from channel orchestrator:events"),
expect.any(Error)
);
});
consoleErrorSpy.mockRestore();
it("should invoke error handler when provided", async () => {
mockRedis.subscribe.mockResolvedValue(1);
let messageHandler: ((channel: string, message: string) => void) | undefined;
mockRedis.on.mockImplementation(
(event: string, handler: (channel: string, message: string) => void) => {
if (event === "message") {
messageHandler = handler;
}
return mockRedis;
}
);
const handler = vi.fn();
const errorHandler = vi.fn();
await client.subscribeToEvents(handler, errorHandler);
// Simulate receiving invalid JSON
if (messageHandler) {
messageHandler("orchestrator:events", "invalid json");
}
expect(handler).not.toHaveBeenCalled();
expect(errorHandler).toHaveBeenCalledWith(
expect.any(Error),
"invalid json",
"orchestrator:events"
);
});
it("should handle errors without logger or error handler", async () => {
mockRedis.subscribe.mockResolvedValue(1);
let messageHandler: ((channel: string, message: string) => void) | undefined;
mockRedis.on.mockImplementation(
(event: string, handler: (channel: string, message: string) => void) => {
if (event === "message") {
messageHandler = handler;
}
return mockRedis;
}
);
const handler = vi.fn();
await client.subscribeToEvents(handler);
// Should not throw when neither logger nor error handler is provided
expect(() => {
if (messageHandler) {
messageHandler("orchestrator:events", "invalid json");
}
}).not.toThrow();
expect(handler).not.toHaveBeenCalled();
});
});
describe('Edge Cases', () => {
it('should handle task updates with error parameter', async () => {
describe("Edge Cases", () => {
it("should handle task updates with error parameter", async () => {
const taskState: TaskState = {
taskId: 'task-123',
status: 'pending',
taskId: "task-123",
status: "pending",
context: {
repository: 'https://github.com/example/repo',
branch: 'main',
workItems: ['item-1'],
repository: "https://github.com/example/repo",
branch: "main",
workItems: ["item-1"],
},
createdAt: '2026-02-02T10:00:00Z',
updatedAt: '2026-02-02T10:00:00Z',
createdAt: "2026-02-02T10:00:00Z",
updatedAt: "2026-02-02T10:00:00Z",
};
mockRedis.get.mockResolvedValue(JSON.stringify(taskState));
mockRedis.set.mockResolvedValue('OK');
mockRedis.set.mockResolvedValue("OK");
const result = await client.updateTaskStatus('task-123', 'failed', undefined, 'Test error');
const result = await client.updateTaskStatus("task-123", "failed", undefined, "Test error");
expect(result.status).toBe('failed');
expect(result.metadata?.error).toBe('Test error');
expect(result.status).toBe("failed");
expect(result.metadata?.error).toBe("Test error");
});
it('should handle agent updates with error parameter', async () => {
it("should handle agent updates with error parameter", async () => {
const agentState: AgentState = {
agentId: 'agent-456',
status: 'running',
taskId: 'task-123',
agentId: "agent-456",
status: "running",
taskId: "task-123",
};
mockRedis.get.mockResolvedValue(JSON.stringify(agentState));
mockRedis.set.mockResolvedValue('OK');
mockRedis.set.mockResolvedValue("OK");
const result = await client.updateAgentStatus('agent-456', 'failed', 'Test error');
const result = await client.updateAgentStatus("agent-456", "failed", "Test error");
expect(result.status).toBe('failed');
expect(result.error).toBe('Test error');
expect(result.status).toBe("failed");
expect(result.error).toBe("Test error");
});
it('should filter out null values in listTasks', async () => {
mockRedis.keys.mockResolvedValue(['orchestrator:task:task-1', 'orchestrator:task:task-2']);
it("should filter out null values in listTasks", async () => {
mockRedis.keys.mockResolvedValue(["orchestrator:task:task-1", "orchestrator:task:task-2"]);
mockRedis.get
.mockResolvedValueOnce(JSON.stringify({ taskId: 'task-1', status: 'pending' }))
.mockResolvedValueOnce(JSON.stringify({ taskId: "task-1", status: "pending" }))
.mockResolvedValueOnce(null); // Simulate deleted task
const result = await client.listTasks();
expect(result).toHaveLength(1);
expect(result[0].taskId).toBe('task-1');
expect(result[0].taskId).toBe("task-1");
});
it('should filter out null values in listAgents', async () => {
mockRedis.keys.mockResolvedValue(['orchestrator:agent:agent-1', 'orchestrator:agent:agent-2']);
it("should filter out null values in listAgents", async () => {
mockRedis.keys.mockResolvedValue([
"orchestrator:agent:agent-1",
"orchestrator:agent:agent-2",
]);
mockRedis.get
.mockResolvedValueOnce(JSON.stringify({ agentId: 'agent-1', status: 'running' }))
.mockResolvedValueOnce(JSON.stringify({ agentId: "agent-1", status: "running" }))
.mockResolvedValueOnce(null); // Simulate deleted agent
const result = await client.listAgents();
expect(result).toHaveLength(1);
expect(result[0].agentId).toBe('agent-1');
expect(result[0].agentId).toBe("agent-1");
});
});
});

61
apps/orchestrator/src/valkey/valkey.client.ts
View File

@@ -1,4 +1,4 @@
import Redis from 'ioredis';
import Redis from "ioredis";
import type {
TaskState,
AgentState,
@@ -6,22 +6,33 @@ import type {
AgentStatus,
OrchestratorEvent,
EventHandler,
} from './types';
import { isValidTaskTransition, isValidAgentTransition } from './types';
} from "./types";
import { isValidTaskTransition, isValidAgentTransition } from "./types";
export interface ValkeyClientConfig {
host: string;
port: number;
password?: string;
db?: number;
logger?: {
error: (message: string, error?: unknown) => void;
};
}
/**
* Error handler for event parsing failures
*/
export type EventErrorHandler = (error: Error, rawMessage: string, channel: string) => void;
/**
* Valkey client for state management and pub/sub
*/
export class ValkeyClient {
private readonly client: Redis;
private subscriber?: Redis;
private readonly logger?: {
error: (message: string, error?: unknown) => void;
};
constructor(config: ValkeyClientConfig) {
this.client = new Redis({
@@ -30,6 +41,7 @@ export class ValkeyClient {
password: config.password,
db: config.db,
});
this.logger = config.logger;
}
/**
@@ -81,9 +93,7 @@ export class ValkeyClient {
// Validate state transition
if (!isValidTaskTransition(existing.status, status)) {
throw new Error(
`Invalid task state transition from ${existing.status} to ${status}`
);
throw new Error(`Invalid task state transition from ${existing.status} to ${status}`);
}
const updated: TaskState = {
@@ -102,7 +112,7 @@ export class ValkeyClient {
}
async listTasks(): Promise<TaskState[]> {
const pattern = 'orchestrator:task:*';
const pattern = "orchestrator:task:*";
const keys = await this.client.keys(pattern);
const tasks: TaskState[] = [];
@@ -154,17 +164,15 @@ export class ValkeyClient {
// Validate state transition
if (!isValidAgentTransition(existing.status, status)) {
throw new Error(
`Invalid agent state transition from ${existing.status} to ${status}`
);
throw new Error(`Invalid agent state transition from ${existing.status} to ${status}`);
}
const now = new Date().toISOString();
const updated: AgentState = {
...existing,
status,
...(status === 'running' && !existing.startedAt && { startedAt: now }),
...((['completed', 'failed', 'killed'] as AgentStatus[]).includes(status) && {
...(status === "running" && !existing.startedAt && { startedAt: now }),
...((["completed", "failed", "killed"] as AgentStatus[]).includes(status) && {
completedAt: now,
}),
...(error && { error }),
@@ -175,7 +183,7 @@ export class ValkeyClient {
}
async listAgents(): Promise<AgentState[]> {
const pattern = 'orchestrator:agent:*';
const pattern = "orchestrator:agent:*";
const keys = await this.client.keys(pattern);
const agents: AgentState[] = [];
@@ -194,25 +202,36 @@ export class ValkeyClient {
*/
async publishEvent(event: OrchestratorEvent): Promise<void> {
const channel = 'orchestrator:events';
const channel = "orchestrator:events";
await this.client.publish(channel, JSON.stringify(event));
}
async subscribeToEvents(handler: EventHandler): Promise<void> {
if (!this.subscriber) {
this.subscriber = this.client.duplicate();
}
async subscribeToEvents(handler: EventHandler, errorHandler?: EventErrorHandler): Promise<void> {
this.subscriber ??= this.client.duplicate();
this.subscriber.on('message', (channel: string, message: string) => {
this.subscriber.on("message", (channel: string, message: string) => {
try {
const event = JSON.parse(message) as OrchestratorEvent;
void handler(event);
} catch (error) {
console.error('Failed to parse event:', error);
const errorObj = error instanceof Error ? error : new Error(String(error));
// Log the error
if (this.logger) {
this.logger.error(
`Failed to parse event from channel ${channel}: ${errorObj.message}`,
errorObj
);
}
// Invoke error handler if provided
if (errorHandler) {
errorHandler(errorObj, message, channel);
}
}
});
await this.subscriber.subscribe('orchestrator:events');
await this.subscriber.subscribe("orchestrator:events");
}
/**

6
apps/orchestrator/src/valkey/valkey.module.ts
View File

@@ -1,6 +1,6 @@
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { ValkeyService } from './valkey.service';
import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";
import { ValkeyService } from "./valkey.service";
/**
* Valkey module for state management and pub/sub

176
apps/orchestrator/src/valkey/valkey.service.spec.ts
View File

@@ -1,7 +1,7 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { ConfigService } from '@nestjs/config';
import { ValkeyService } from './valkey.service';
import type { TaskState, AgentState, OrchestratorEvent } from './types';
import { describe, it, expect, beforeEach, vi } from "vitest";
import { ConfigService } from "@nestjs/config";
import { ValkeyService } from "./valkey.service";
import type { TaskState, AgentState, OrchestratorEvent } from "./types";
// Create mock client methods that will be shared
const mockClient = {
@@ -21,7 +21,7 @@ const mockClient = {
};
// Mock ValkeyClient before importing
vi.mock('./valkey.client', () => {
vi.mock("./valkey.client", () => {
return {
ValkeyClient: class {
constructor() {
@@ -31,7 +31,7 @@ vi.mock('./valkey.client', () => {
};
});
describe('ValkeyService', () => {
describe("ValkeyService", () => {
let service: ValkeyService;
let mockConfigService: ConfigService;
@@ -43,47 +43,47 @@ describe('ValkeyService', () => {
mockConfigService = {
get: vi.fn((key: string, defaultValue?: unknown) => {
const config: Record<string, unknown> = {
'orchestrator.valkey.host': 'localhost',
'orchestrator.valkey.port': 6379,
"orchestrator.valkey.host": "localhost",
"orchestrator.valkey.port": 6379,
};
return config[key] ?? defaultValue;
}),
} as any;
} as unknown as ConfigService;
// Create service directly
service = new ValkeyService(mockConfigService);
});
describe('Initialization', () => {
it('should be defined', () => {
describe("Initialization", () => {
it("should be defined", () => {
expect(service).toBeDefined();
});
it('should create ValkeyClient with config from ConfigService', () => {
expect(mockConfigService.get).toHaveBeenCalledWith('orchestrator.valkey.host', 'localhost');
expect(mockConfigService.get).toHaveBeenCalledWith('orchestrator.valkey.port', 6379);
it("should create ValkeyClient with config from ConfigService", () => {
expect(mockConfigService.get).toHaveBeenCalledWith("orchestrator.valkey.host", "localhost");
expect(mockConfigService.get).toHaveBeenCalledWith("orchestrator.valkey.port", 6379);
});
it('should use password from config if provided', () => {
it("should use password from config if provided", () => {
const configWithPassword = {
get: vi.fn((key: string, defaultValue?: unknown) => {
const config: Record<string, unknown> = {
'orchestrator.valkey.host': 'localhost',
'orchestrator.valkey.port': 6379,
'orchestrator.valkey.password': 'secret',
"orchestrator.valkey.host": "localhost",
"orchestrator.valkey.port": 6379,
"orchestrator.valkey.password": "secret",
};
return config[key] ?? defaultValue;
}),
} as any;
} as unknown as ConfigService;
const serviceWithPassword = new ValkeyService(configWithPassword);
expect(configWithPassword.get).toHaveBeenCalledWith('orchestrator.valkey.password');
expect(configWithPassword.get).toHaveBeenCalledWith("orchestrator.valkey.password");
});
});
describe('Lifecycle', () => {
it('should disconnect on module destroy', async () => {
describe("Lifecycle", () => {
it("should disconnect on module destroy", async () => {
mockClient.disconnect.mockResolvedValue(undefined);
await service.onModuleDestroy();
@@ -92,29 +92,29 @@ describe('ValkeyService', () => {
});
});
describe('Task State Management', () => {
describe("Task State Management", () => {
const mockTaskState: TaskState = {
taskId: 'task-123',
status: 'pending',
taskId: "task-123",
status: "pending",
context: {
repository: 'https://github.com/example/repo',
branch: 'main',
workItems: ['item-1'],
repository: "https://github.com/example/repo",
branch: "main",
workItems: ["item-1"],
},
createdAt: '2026-02-02T10:00:00Z',
updatedAt: '2026-02-02T10:00:00Z',
createdAt: "2026-02-02T10:00:00Z",
updatedAt: "2026-02-02T10:00:00Z",
};
it('should get task state', async () => {
it("should get task state", async () => {
mockClient.getTaskState.mockResolvedValue(mockTaskState);
const result = await service.getTaskState('task-123');
const result = await service.getTaskState("task-123");
expect(mockClient.getTaskState).toHaveBeenCalledWith('task-123');
expect(mockClient.getTaskState).toHaveBeenCalledWith("task-123");
expect(result).toEqual(mockTaskState);
});
it('should set task state', async () => {
it("should set task state", async () => {
mockClient.setTaskState.mockResolvedValue(undefined);
await service.setTaskState(mockTaskState);
@@ -122,30 +122,30 @@ describe('ValkeyService', () => {
expect(mockClient.setTaskState).toHaveBeenCalledWith(mockTaskState);
});
it('should delete task state', async () => {
it("should delete task state", async () => {
mockClient.deleteTaskState.mockResolvedValue(undefined);
await service.deleteTaskState('task-123');
await service.deleteTaskState("task-123");
expect(mockClient.deleteTaskState).toHaveBeenCalledWith('task-123');
expect(mockClient.deleteTaskState).toHaveBeenCalledWith("task-123");
});
it('should update task status', async () => {
const updatedTask = { ...mockTaskState, status: 'assigned' as const };
it("should update task status", async () => {
const updatedTask = { ...mockTaskState, status: "assigned" as const };
mockClient.updateTaskStatus.mockResolvedValue(updatedTask);
const result = await service.updateTaskStatus('task-123', 'assigned', 'agent-456');
const result = await service.updateTaskStatus("task-123", "assigned", "agent-456");
expect(mockClient.updateTaskStatus).toHaveBeenCalledWith(
'task-123',
'assigned',
'agent-456',
"task-123",
"assigned",
"agent-456",
undefined
);
expect(result).toEqual(updatedTask);
});
it('should list all tasks', async () => {
it("should list all tasks", async () => {
const tasks = [mockTaskState];
mockClient.listTasks.mockResolvedValue(tasks);
@@ -156,23 +156,23 @@ describe('ValkeyService', () => {
});
});
describe('Agent State Management', () => {
describe("Agent State Management", () => {
const mockAgentState: AgentState = {
agentId: 'agent-456',
status: 'spawning',
taskId: 'task-123',
agentId: "agent-456",
status: "spawning",
taskId: "task-123",
};
it('should get agent state', async () => {
it("should get agent state", async () => {
mockClient.getAgentState.mockResolvedValue(mockAgentState);
const result = await service.getAgentState('agent-456');
const result = await service.getAgentState("agent-456");
expect(mockClient.getAgentState).toHaveBeenCalledWith('agent-456');
expect(mockClient.getAgentState).toHaveBeenCalledWith("agent-456");
expect(result).toEqual(mockAgentState);
});
it('should set agent state', async () => {
it("should set agent state", async () => {
mockClient.setAgentState.mockResolvedValue(undefined);
await service.setAgentState(mockAgentState);
@@ -180,29 +180,25 @@ describe('ValkeyService', () => {
expect(mockClient.setAgentState).toHaveBeenCalledWith(mockAgentState);
});
it('should delete agent state', async () => {
it("should delete agent state", async () => {
mockClient.deleteAgentState.mockResolvedValue(undefined);
await service.deleteAgentState('agent-456');
await service.deleteAgentState("agent-456");
expect(mockClient.deleteAgentState).toHaveBeenCalledWith('agent-456');
expect(mockClient.deleteAgentState).toHaveBeenCalledWith("agent-456");
});
it('should update agent status', async () => {
const updatedAgent = { ...mockAgentState, status: 'running' as const };
it("should update agent status", async () => {
const updatedAgent = { ...mockAgentState, status: "running" as const };
mockClient.updateAgentStatus.mockResolvedValue(updatedAgent);
const result = await service.updateAgentStatus('agent-456', 'running');
const result = await service.updateAgentStatus("agent-456", "running");
expect(mockClient.updateAgentStatus).toHaveBeenCalledWith(
'agent-456',
'running',
undefined
);
expect(mockClient.updateAgentStatus).toHaveBeenCalledWith("agent-456", "running", undefined);
expect(result).toEqual(updatedAgent);
});
it('should list all agents', async () => {
it("should list all agents", async () => {
const agents = [mockAgentState];
mockClient.listAgents.mockResolvedValue(agents);
@@ -213,15 +209,15 @@ describe('ValkeyService', () => {
});
});
describe('Event Pub/Sub', () => {
describe("Event Pub/Sub", () => {
const mockEvent: OrchestratorEvent = {
type: 'agent.spawned',
agentId: 'agent-456',
taskId: 'task-123',
timestamp: '2026-02-02T10:00:00Z',
type: "agent.spawned",
agentId: "agent-456",
taskId: "task-123",
timestamp: "2026-02-02T10:00:00Z",
};
it('should publish events', async () => {
it("should publish events", async () => {
mockClient.publishEvent.mockResolvedValue(undefined);
await service.publishEvent(mockEvent);
@@ -229,46 +225,56 @@ describe('ValkeyService', () => {
expect(mockClient.publishEvent).toHaveBeenCalledWith(mockEvent);
});
it('should subscribe to events', async () => {
it("should subscribe to events", async () => {
mockClient.subscribeToEvents.mockResolvedValue(undefined);
const handler = vi.fn();
await service.subscribeToEvents(handler);
expect(mockClient.subscribeToEvents).toHaveBeenCalledWith(handler);
expect(mockClient.subscribeToEvents).toHaveBeenCalledWith(handler, undefined);
});
it("should subscribe to events with error handler", async () => {
mockClient.subscribeToEvents.mockResolvedValue(undefined);
const handler = vi.fn();
const errorHandler = vi.fn();
await service.subscribeToEvents(handler, errorHandler);
expect(mockClient.subscribeToEvents).toHaveBeenCalledWith(handler, errorHandler);
});
});
describe('Convenience Methods', () => {
it('should create task state with timestamps', async () => {
describe("Convenience Methods", () => {
it("should create task state with timestamps", async () => {
mockClient.setTaskState.mockResolvedValue(undefined);
const context = {
repository: 'https://github.com/example/repo',
branch: 'main',
workItems: ['item-1'],
repository: "https://github.com/example/repo",
branch: "main",
workItems: ["item-1"],
};
await service.createTask('task-123', context);
await service.createTask("task-123", context);
expect(mockClient.setTaskState).toHaveBeenCalledWith({
taskId: 'task-123',
status: 'pending',
taskId: "task-123",
status: "pending",
context,
createdAt: expect.any(String),
updatedAt: expect.any(String),
});
});
it('should create agent state', async () => {
it("should create agent state", async () => {
mockClient.setAgentState.mockResolvedValue(undefined);
await service.createAgent('agent-456', 'task-123');
await service.createAgent("agent-456", "task-123");
expect(mockClient.setAgentState).toHaveBeenCalledWith({
agentId: 'agent-456',
status: 'spawning',
taskId: 'task-123',
agentId: "agent-456",
status: "spawning",
taskId: "task-123",
});
});
});

28
apps/orchestrator/src/valkey/valkey.service.ts
View File

@@ -1,6 +1,6 @@
import { Injectable, OnModuleDestroy } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { ValkeyClient, ValkeyClientConfig } from './valkey.client';
import { Injectable, OnModuleDestroy, Logger } from "@nestjs/common";
import { ConfigService } from "@nestjs/config";
import { ValkeyClient, ValkeyClientConfig, EventErrorHandler } from "./valkey.client";
import type {
TaskState,
AgentState,
@@ -9,7 +9,7 @@ import type {
OrchestratorEvent,
EventHandler,
TaskContext,
} from './types';
} from "./types";
/**
* NestJS service for Valkey state management and pub/sub
@@ -17,14 +17,20 @@ import type {
@Injectable()
export class ValkeyService implements OnModuleDestroy {
private readonly client: ValkeyClient;
private readonly logger = new Logger(ValkeyService.name);
constructor(private readonly configService: ConfigService) {
const config: ValkeyClientConfig = {
host: this.configService.get<string>('orchestrator.valkey.host', 'localhost'),
port: this.configService.get<number>('orchestrator.valkey.port', 6379),
host: this.configService.get<string>("orchestrator.valkey.host", "localhost"),
port: this.configService.get<number>("orchestrator.valkey.port", 6379),
logger: {
error: (message: string, error?: unknown) => {
this.logger.error(message, error instanceof Error ? error.stack : String(error));
},
},
};
const password = this.configService.get<string>('orchestrator.valkey.password');
const password = this.configService.get<string>("orchestrator.valkey.password");
if (password) {
config.password = password;
}
@@ -101,8 +107,8 @@ export class ValkeyService implements OnModuleDestroy {
return this.client.publishEvent(event);
}
async subscribeToEvents(handler: EventHandler): Promise<void> {
return this.client.subscribeToEvents(handler);
async subscribeToEvents(handler: EventHandler, errorHandler?: EventErrorHandler): Promise<void> {
return this.client.subscribeToEvents(handler, errorHandler);
}
/**
@@ -113,7 +119,7 @@ export class ValkeyService implements OnModuleDestroy {
const now = new Date().toISOString();
const state: TaskState = {
taskId,
status: 'pending',
status: "pending",
context,
createdAt: now,
updatedAt: now,
@@ -124,7 +130,7 @@ export class ValkeyService implements OnModuleDestroy {
async createAgent(agentId: string, taskId: string): Promise<void> {
const state: AgentState = {
agentId,
status: 'spawning',
status: "spawning",
taskId,
};
await this.setAgentState(state);