Files
EJClaw/src/message-runtime-progress-entry.test.ts
Codex 8c68577a24 refactor: replace the Claude→Codex failover with a usage-limit notice
When Claude hit a limit the run was handed to a Codex service
(codex-main/codex-review) through service_handoffs and a global owner
failover. That service does not exist in this deployment, so handoffs
stayed pending forever (2 rows since May) and the user got no answer.

Removed:
- handoff creation (message-agent-executor-handoff, paired-turn-fallback)
  and the delegated paired-execution path
- the pending-handoff poll/claim worker (message-runtime-handoffs) and the
  service_handoffs CRUD module (db/service-handoffs, db exports)
- global owner failover in service-routing, its recovery timer in index,
  the dashboard failover line, the codex-review failover prompt pack and
  prompts/codex-review-failover-platform.md
- failoverOwner in RoomRoleContext and the `failover=` ROOM_ROLE field
- OWNER_/REVIEWER_/ARBITER_FALLBACK_ENABLED and FAILOVER_MIN_DURATION_MS
- tests for the removed behaviour

Now, when a Claude run fails with a usage/rate limit (trigger reason
429 or usage-exhausted) the executor closes the open paired task as
completed/claude_usage_limit and sends the room one final notice:
"Claude 사용 한도에 도달했습니다. 21:40에 재개할 수 있습니다." The reset time
comes from the error text (CLI banner "resets 9:40pm (Asia/Seoul)", dated
banners, "try again at ...", ISO timestamps), else from the cached usage
API window at 100%, else "잠시 후 다시 시도해 주세요". Nothing retries
silently; the next user message starts a new task. Other Claude failures
(session failure, org access denied) now end as ordinary run errors.

The service_handoffs table, its columns on paired_turn_attempts and the
migrations stay untouched for the later migration squash; the runtime no
longer reads or writes them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-01 20:14:48 +09:00

140 lines
4.1 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from 'vitest';
const runtimeMocks = vi.hoisted(() => ({
executeTurn: vi.fn(async () => ({
outputStatus: 'success' as const,
deliverySucceeded: true,
visiblePhase: 'progress' as const,
})),
}));
vi.mock('./message-runtime-turns.js', () => ({
createRunAgent: vi.fn(() => vi.fn()),
createExecuteTurn: vi.fn(() => runtimeMocks.executeTurn),
isDuplicateOfLastBotFinal: vi.fn(() => false),
labelPairedSenders: vi.fn((_channels, _chatJid, messages) => messages),
}));
import {
_initTestDatabase,
_setRegisteredGroupForTests,
getLatestOpenPairedTaskForChat,
storeChatMetadata,
storeMessage,
} from './db.js';
import { createMessageRuntime } from './message-runtime.js';
import { refreshChannelOwnerCache } from './service-routing.js';
import type { Channel, RegisteredGroup } from './types.js';
const chatJid = 'group@test';
const timestamp = '2026-04-30T00:30:00.000Z';
function makeGroup(): RegisteredGroup {
return {
name: 'Test Group',
folder: 'test-group',
trigger: '@Andy',
added_at: timestamp,
requiresTrigger: false,
agentType: 'codex',
workDir: process.cwd(),
};
}
function makeChannel(name: string, ownsJid: boolean): Channel {
return {
name,
connect: vi.fn(),
sendMessage: vi.fn(),
isConnected: vi.fn(() => true),
ownsJid: vi.fn((jid: string) => ownsJid && jid === chatJid),
disconnect: vi.fn(),
setTyping: vi.fn(),
} as unknown as Channel;
}
describe('message-runtime progress entry path', () => {
beforeEach(() => {
_initTestDatabase();
refreshChannelOwnerCache(true);
runtimeMocks.executeTurn.mockClear();
runtimeMocks.executeTurn.mockResolvedValue({
outputStatus: 'success',
deliverySucceeded: true,
visiblePhase: 'progress',
});
});
it('passes pairedTurnIdentity through the production owner-turn entry path when no task is open', async () => {
const group = makeGroup();
const ownerChannel = makeChannel('discord', true);
const reviewerChannel = makeChannel('discord-review', false);
const lastAgentTimestamps: Record<string, string> = {};
const saveState = vi.fn();
_setRegisteredGroupForTests(chatJid, {
...group,
agentType: 'claude-code',
});
_setRegisteredGroupForTests(chatJid, group);
refreshChannelOwnerCache(true);
storeChatMetadata(chatJid, timestamp, 'Test Group');
storeMessage({
id: 'human-first-owner-turn',
chat_jid: chatJid,
sender: 'user@test',
sender_name: 'User',
content: '디스코드에는 progress가 보이는데 사이트에는 안 보여요',
timestamp,
is_bot_message: false,
is_from_me: false,
});
const runtime = createMessageRuntime({
assistantName: 'Andy',
idleTimeout: 1_000,
pollInterval: 1_000,
timezone: 'UTC',
channels: [ownerChannel, reviewerChannel],
queue: {
enqueueMessageCheck: vi.fn(),
registerProcess: vi.fn(),
closeStdin: vi.fn(),
notifyIdle: vi.fn(),
} as any,
getRoomBindings: () => ({ [chatJid]: group }),
getSessions: () => ({}),
getLastTimestamp: () => '',
setLastTimestamp: vi.fn(),
getLastAgentTimestamps: () => lastAgentTimestamps,
saveState,
persistSession: vi.fn(),
clearSession: vi.fn(),
});
const result = await runtime.processGroupMessages(chatJid, {
runId: 'run-first-owner-entry',
reason: 'messages',
});
const freshTask = getLatestOpenPairedTaskForChat(chatJid);
expect(result).toBe(true);
expect(freshTask).toBeDefined();
expect(runtimeMocks.executeTurn).toHaveBeenCalledWith(
expect.objectContaining({
deliveryRole: 'owner',
forcedRole: 'owner',
pairedTurnIdentity: {
turnId: `${freshTask!.id}:${freshTask!.updated_at}:owner-turn`,
taskId: freshTask!.id,
taskUpdatedAt: freshTask!.updated_at,
intentKind: 'owner-turn',
role: 'owner',
},
}),
);
expect(lastAgentTimestamps).toEqual({ [chatJid]: '1' });
expect(saveState).toHaveBeenCalled();
});
});