4774 lines
155 KiB
TypeScript
4774 lines
155 KiB
TypeScript
import { chmod, cp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
|
|
import path from 'node:path';
|
|
import type { FastifyBaseLogger } from 'fastify';
|
|
import type { IncomingMessage } from 'node:http';
|
|
import type { Socket } from 'node:net';
|
|
import { WebSocketServer, type RawData, type WebSocket } from 'ws';
|
|
import { env } from '../config/env.js';
|
|
import { db } from '../db/client.js';
|
|
import { getAppConfigSnapshot, getChatContextSettingsConfig, getChatTypesConfig } from './app-config-service.js';
|
|
import { BOARD_POSTS_TABLE } from './board-service.js';
|
|
import {
|
|
appendChatConversationMessage,
|
|
appendChatConversationActivityLine,
|
|
getChatConversationRequest,
|
|
getChatConversation,
|
|
listChatConversationOfflineNotificationClientIds,
|
|
listRecoverableChatConversationRequests,
|
|
listChatConversationMessages,
|
|
listChatConversationRequests,
|
|
upsertChatConversationRequest,
|
|
updateChatConversationJobState,
|
|
updateChatConversationContext,
|
|
} from './chat-room-service.js';
|
|
import { chatRuntimeService, type ChatRuntimeJobDetail, type ChatRuntimeSnapshot } from './chat-runtime-service.js';
|
|
import { hasErrorLogViewAccessToken } from './error-log-service.js';
|
|
import { sendNotifications } from './notification-service.js';
|
|
import { createNotificationMessage } from './notification-message-service.js';
|
|
import {
|
|
subscribeNotificationMessageChanges,
|
|
type NotificationMessageChangeEvent,
|
|
} from './notification-message-service.js';
|
|
import { extractChatMessageParts, type ChatMessagePart } from './chat-message-parts.js';
|
|
import { resolveMainProjectRoot } from './main-project-root-service.js';
|
|
import {
|
|
findLatestPlanItem,
|
|
findPlanItemByPreviewUrl,
|
|
findPlanItemByWorkId,
|
|
getPlanItemById,
|
|
listPlanActionHistories,
|
|
listPlanIssueHistories,
|
|
listPlanSourceWorkHistories,
|
|
mapPlanActionRow,
|
|
mapPlanIssueRow,
|
|
mapPlanSourceWorkRow,
|
|
PLAN_TABLE,
|
|
} from './plan-service.js';
|
|
|
|
type ChatAuthor = 'codex' | 'system' | 'user';
|
|
|
|
type ChatMessage = {
|
|
id: number;
|
|
author: ChatAuthor;
|
|
text: string;
|
|
timestamp: string;
|
|
clientRequestId?: string | null;
|
|
parts?: ChatMessagePart[];
|
|
};
|
|
|
|
type ChatContext = {
|
|
pageId: string | null;
|
|
pageTitle: string;
|
|
topMenu: string;
|
|
focusedComponentId: string | null;
|
|
pageUrl: string;
|
|
isStandaloneMode?: boolean;
|
|
pageVisibilityState?: 'visible' | 'hidden';
|
|
pageFocusState?: 'focused' | 'blurred';
|
|
chatTypeId?: string | null;
|
|
chatTypeLabel?: string;
|
|
chatTypeDescription?: string;
|
|
chatTypeBaseDescription?: string;
|
|
defaultContextIds?: string[];
|
|
defaultContexts?: Array<{
|
|
id?: string;
|
|
title?: string;
|
|
content?: string;
|
|
}>;
|
|
customContextTitle?: string | null;
|
|
customContextContent?: string | null;
|
|
};
|
|
|
|
type ChatInboundMessage =
|
|
| {
|
|
type: 'context:update';
|
|
payload: ChatContext;
|
|
}
|
|
| {
|
|
type: 'presence:ping';
|
|
payload?: {
|
|
at?: number;
|
|
};
|
|
}
|
|
| {
|
|
type: 'event:received';
|
|
payload: {
|
|
eventId: number;
|
|
};
|
|
}
|
|
| {
|
|
type: 'message:send';
|
|
payload: {
|
|
text: string;
|
|
requestId?: string;
|
|
mode?: 'queue' | 'direct';
|
|
omitPromptHistory?: boolean;
|
|
chatTypeId?: string | null;
|
|
chatTypeLabel?: string;
|
|
chatTypeDescription?: string;
|
|
chatTypeBaseDescription?: string;
|
|
defaultContextIds?: string[];
|
|
defaultContexts?: Array<{
|
|
id?: string;
|
|
title?: string;
|
|
content?: string;
|
|
}>;
|
|
customContextTitle?: string | null;
|
|
customContextContent?: string | null;
|
|
};
|
|
}
|
|
| {
|
|
type: 'runtime:watch';
|
|
payload: {
|
|
requestId?: string | null;
|
|
};
|
|
};
|
|
|
|
type ChatOutboundPayload =
|
|
| {
|
|
type: 'chat:init';
|
|
payload: {
|
|
messages: ChatMessage[];
|
|
};
|
|
}
|
|
| {
|
|
type: 'chat:message';
|
|
payload: ChatMessage;
|
|
}
|
|
| {
|
|
type: 'chat:message:update';
|
|
payload: ChatMessage;
|
|
}
|
|
| {
|
|
type: 'chat:status';
|
|
payload: {
|
|
connectedAt: string;
|
|
};
|
|
}
|
|
| {
|
|
type: 'chat:job';
|
|
payload: {
|
|
requestId: string;
|
|
status: 'queued' | 'started' | 'completed' | 'failed';
|
|
mode: 'queue' | 'direct';
|
|
queueSize: number;
|
|
message: string;
|
|
};
|
|
}
|
|
| {
|
|
type: 'chat:error';
|
|
payload: {
|
|
message: string;
|
|
};
|
|
}
|
|
| {
|
|
type: 'chat:runtime';
|
|
payload: ChatRuntimeSnapshot;
|
|
}
|
|
| {
|
|
type: 'chat:runtime:detail';
|
|
payload: ChatRuntimeJobDetail;
|
|
}
|
|
| {
|
|
type: 'chat:activity';
|
|
payload: {
|
|
requestId: string;
|
|
line: string;
|
|
lineCount: number;
|
|
lineNo?: number;
|
|
};
|
|
}
|
|
| {
|
|
type: 'notification:messages-updated';
|
|
payload:
|
|
| {
|
|
action: 'created' | 'updated';
|
|
itemId: number;
|
|
category: string;
|
|
read: boolean;
|
|
}
|
|
| {
|
|
action: 'deleted';
|
|
itemId: number;
|
|
};
|
|
};
|
|
|
|
type ChatOutboundMessage = ChatOutboundPayload & {
|
|
eventId: number;
|
|
sessionId: string;
|
|
};
|
|
|
|
type ChatSessionState = {
|
|
sessionId: string;
|
|
clientId: string | null;
|
|
socket: WebSocket | null;
|
|
lastSeenAt: number;
|
|
isDeleted: boolean;
|
|
context: ChatContext | null;
|
|
queue: Array<{
|
|
requestId: string;
|
|
text: string;
|
|
mode: 'queue' | 'direct';
|
|
requestedAtMs: number;
|
|
omitPromptHistory?: boolean;
|
|
context: ChatContext | null;
|
|
}>;
|
|
activeRequestCount: number;
|
|
pendingQueueReleaseEventId: number | null;
|
|
nextEventId: number;
|
|
eventHistory: ChatOutboundMessage[];
|
|
messagePersistenceTail: Promise<void>;
|
|
watchedRuntimeRequestId: string | null;
|
|
};
|
|
|
|
type ChatRuntimeController = {
|
|
getJobDetail: (requestId: string) => ReturnType<typeof chatRuntimeService.getJobDetail>;
|
|
cancelJob: (requestId: string) => Promise<boolean>;
|
|
removeQueuedJob: (requestId: string) => Promise<boolean>;
|
|
};
|
|
|
|
type ActiveChatExecution = {
|
|
cancel: () => Promise<boolean> | boolean;
|
|
};
|
|
|
|
let activeRuntimeController: ChatRuntimeController | null = null;
|
|
let activeChatService: ChatService | null = null;
|
|
const activeChatProcessRegistry = new Map<string, ActiveChatExecution>();
|
|
|
|
export function getChatRuntimeController() {
|
|
return activeRuntimeController;
|
|
}
|
|
|
|
export function getActiveChatService() {
|
|
return activeChatService;
|
|
}
|
|
|
|
const SOCKET_PATH = '/ws/chat';
|
|
const KST_TIME_ZONE = 'Asia/Seoul';
|
|
const STREAM_CAPTURE_LIMIT = 256 * 1024;
|
|
const CHAT_PUBLIC_RESOURCE_DIR = '.codex_chat';
|
|
const CHAT_PUBLIC_RESOURCE_SUBDIR = 'resource';
|
|
const CHAT_API_RESOURCE_ROUTE_PREFIX = '/api/chat/resources';
|
|
const CHAT_SESSION_REFERENCE_RESOURCE_RELATIVE_PATH = 'source/chat-room-reference.md';
|
|
const CHAT_SESSION_REFERENCE_AUTO_START = '<!-- codex-live:auto:start -->';
|
|
const CHAT_SESSION_REFERENCE_AUTO_END = '<!-- codex-live:auto:end -->';
|
|
const CHAT_SESSION_RESOURCE_DIR_MODE = 0o777;
|
|
const SOCKET_READY_STATE_OPEN = 1;
|
|
const CHAT_ACTIVITY_MESSAGE_PREFIX = '[[activity-log]]';
|
|
const MAX_CHAT_ACTIVITY_MESSAGE_LINES = 240;
|
|
const MAX_CHAT_ACTIVITY_MESSAGE_CHARS = 80_000;
|
|
const CHAT_OFFLINE_PUSH_SUPPRESSION_WINDOW_MS = 15_000;
|
|
const CHAT_PROMPT_HISTORY_MAX_MESSAGES = 12;
|
|
const CHAT_PROMPT_HISTORY_MAX_CHARS = 3200;
|
|
const CHAT_SESSION_EVENT_HISTORY_LIMIT = 400;
|
|
let chatMessageSequence = 0;
|
|
|
|
export function isChatClientActivelyViewing(clientId: string | null | undefined, sessions: Iterable<ChatSessionState>) {
|
|
return evaluateChatClientActiveViewing(clientId, sessions).isActive;
|
|
}
|
|
|
|
function evaluateChatClientActiveViewing(clientId: string | null | undefined, sessions: Iterable<ChatSessionState>, nowMs = Date.now()) {
|
|
const normalizedClientId = clientId?.trim();
|
|
|
|
if (!normalizedClientId) {
|
|
return {
|
|
isActive: false,
|
|
matchedSessions: [],
|
|
};
|
|
}
|
|
|
|
const matchedSessions: Array<{
|
|
sessionId: string;
|
|
lastSeenAt: number;
|
|
presenceAgeMs: number;
|
|
socketReadyState: number | null;
|
|
pageVisibilityState: 'visible' | 'hidden';
|
|
pageFocusState: 'focused' | 'blurred';
|
|
pageOrigin: string | null;
|
|
reason:
|
|
| 'socket-not-open'
|
|
| 'stale-presence'
|
|
| 'backgrounded'
|
|
| 'active-no-page-url'
|
|
| 'active-supported-origin'
|
|
| 'unsupported-origin'
|
|
| 'invalid-page-url';
|
|
}> = [];
|
|
|
|
for (const session of sessions) {
|
|
if (session.clientId?.trim() !== normalizedClientId) {
|
|
continue;
|
|
}
|
|
|
|
const pageVisibilityState = session.context?.pageVisibilityState ?? 'visible';
|
|
const pageFocusState = session.context?.pageFocusState ?? 'focused';
|
|
const pageUrl = session.context?.pageUrl?.trim();
|
|
const presenceAgeMs = Math.max(0, nowMs - session.lastSeenAt);
|
|
const socketReadyState = session.socket?.readyState ?? null;
|
|
|
|
if (!session.socket || session.socket.readyState !== SOCKET_READY_STATE_OPEN) {
|
|
matchedSessions.push({
|
|
sessionId: session.sessionId,
|
|
lastSeenAt: session.lastSeenAt,
|
|
presenceAgeMs,
|
|
socketReadyState,
|
|
pageVisibilityState,
|
|
pageFocusState,
|
|
pageOrigin: null,
|
|
reason: 'socket-not-open',
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const hasFreshPresence = presenceAgeMs < CHAT_OFFLINE_PUSH_SUPPRESSION_WINDOW_MS;
|
|
|
|
if (!hasFreshPresence) {
|
|
matchedSessions.push({
|
|
sessionId: session.sessionId,
|
|
lastSeenAt: session.lastSeenAt,
|
|
presenceAgeMs,
|
|
socketReadyState,
|
|
pageVisibilityState,
|
|
pageFocusState,
|
|
pageOrigin: null,
|
|
reason: 'stale-presence',
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (pageVisibilityState === 'hidden' || pageFocusState === 'blurred') {
|
|
matchedSessions.push({
|
|
sessionId: session.sessionId,
|
|
lastSeenAt: session.lastSeenAt,
|
|
presenceAgeMs,
|
|
socketReadyState,
|
|
pageVisibilityState,
|
|
pageFocusState,
|
|
pageOrigin: null,
|
|
reason: 'backgrounded',
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (!pageUrl) {
|
|
matchedSessions.push({
|
|
sessionId: session.sessionId,
|
|
lastSeenAt: session.lastSeenAt,
|
|
presenceAgeMs,
|
|
socketReadyState,
|
|
pageVisibilityState,
|
|
pageFocusState,
|
|
pageOrigin: null,
|
|
reason: 'active-no-page-url',
|
|
});
|
|
return {
|
|
isActive: true,
|
|
matchedSessions,
|
|
};
|
|
}
|
|
|
|
try {
|
|
const resolvedUrl = new URL(pageUrl);
|
|
|
|
if (resolvedUrl.origin === 'https://preview.sm-home.cloud' || resolvedUrl.origin === 'https://test.sm-home.cloud') {
|
|
matchedSessions.push({
|
|
sessionId: session.sessionId,
|
|
lastSeenAt: session.lastSeenAt,
|
|
presenceAgeMs,
|
|
socketReadyState,
|
|
pageVisibilityState,
|
|
pageFocusState,
|
|
pageOrigin: resolvedUrl.origin,
|
|
reason: 'active-supported-origin',
|
|
});
|
|
return {
|
|
isActive: true,
|
|
matchedSessions,
|
|
};
|
|
}
|
|
|
|
matchedSessions.push({
|
|
sessionId: session.sessionId,
|
|
lastSeenAt: session.lastSeenAt,
|
|
presenceAgeMs,
|
|
socketReadyState,
|
|
pageVisibilityState,
|
|
pageFocusState,
|
|
pageOrigin: resolvedUrl.origin,
|
|
reason: 'unsupported-origin',
|
|
});
|
|
} catch {
|
|
matchedSessions.push({
|
|
sessionId: session.sessionId,
|
|
lastSeenAt: session.lastSeenAt,
|
|
presenceAgeMs,
|
|
socketReadyState,
|
|
pageVisibilityState,
|
|
pageFocusState,
|
|
pageOrigin: null,
|
|
reason: 'invalid-page-url',
|
|
});
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return {
|
|
isActive: false,
|
|
matchedSessions,
|
|
};
|
|
}
|
|
|
|
function logChatClientActiveViewingEvaluation(
|
|
logger: FastifyBaseLogger,
|
|
clientId: string,
|
|
evaluation: ReturnType<typeof evaluateChatClientActiveViewing>,
|
|
) {
|
|
if (evaluation.matchedSessions.length === 0) {
|
|
logger.info(
|
|
{
|
|
clientId,
|
|
active: false,
|
|
reason: 'no-matching-session',
|
|
},
|
|
'chat offline notification presence evaluation',
|
|
);
|
|
return;
|
|
}
|
|
|
|
for (const sessionState of evaluation.matchedSessions) {
|
|
logger.info(
|
|
{
|
|
clientId,
|
|
active: evaluation.isActive,
|
|
sessionId: sessionState.sessionId,
|
|
lastSeenAt: sessionState.lastSeenAt,
|
|
presenceAgeMs: sessionState.presenceAgeMs,
|
|
socketReadyState: sessionState.socketReadyState,
|
|
pageVisibilityState: sessionState.pageVisibilityState,
|
|
pageFocusState: sessionState.pageFocusState,
|
|
pageOrigin: sessionState.pageOrigin,
|
|
reason: sessionState.reason,
|
|
},
|
|
'chat offline notification presence evaluation',
|
|
);
|
|
}
|
|
}
|
|
|
|
export function resolveChatContextAppOrigin(context: ChatContext | null | undefined) {
|
|
const pageUrl = context?.pageUrl?.trim();
|
|
|
|
if (!pageUrl) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
return new URL(pageUrl).origin;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function buildChatNotificationTargetUrl(context: ChatContext | null, sessionId: string) {
|
|
const fallbackUrl = new URL('https://preview.sm-home.cloud/chat/live');
|
|
fallbackUrl.searchParams.set('topMenu', 'chat');
|
|
fallbackUrl.searchParams.set('sessionId', sessionId);
|
|
|
|
const pageUrl = context?.pageUrl?.trim();
|
|
|
|
if (!pageUrl) {
|
|
return fallbackUrl.toString();
|
|
}
|
|
|
|
try {
|
|
const targetUrl = new URL(pageUrl);
|
|
targetUrl.pathname = '/chat/live';
|
|
targetUrl.searchParams.set('topMenu', targetUrl.searchParams.get('topMenu') || 'chat');
|
|
targetUrl.searchParams.set('sessionId', sessionId);
|
|
targetUrl.searchParams.delete('chatView');
|
|
targetUrl.searchParams.delete('runtimeRequestId');
|
|
return targetUrl.toString();
|
|
} catch {
|
|
return fallbackUrl.toString();
|
|
}
|
|
}
|
|
|
|
function createChatNotificationPreview(text: string) {
|
|
const normalized = String(text ?? '').replace(/\s+/g, ' ').trim();
|
|
return normalized.length > 140 ? `${normalized.slice(0, 137).trimEnd()}...` : normalized;
|
|
}
|
|
|
|
function createChatQuestionAnswerNotificationBody(args: {
|
|
questionText?: string | null;
|
|
answerText?: string | null;
|
|
fallback: string;
|
|
}) {
|
|
const questionPreview = createChatNotificationPreview(args.questionText ?? '');
|
|
const answerPreview = createChatNotificationPreview(args.answerText ?? '');
|
|
|
|
if (questionPreview && answerPreview) {
|
|
return `질문: ${questionPreview}\n답변: ${answerPreview}`;
|
|
}
|
|
|
|
if (answerPreview) {
|
|
return `답변: ${answerPreview}`;
|
|
}
|
|
|
|
if (questionPreview) {
|
|
return `질문: ${questionPreview}`;
|
|
}
|
|
|
|
return args.fallback;
|
|
}
|
|
|
|
function normalizeStructuredChatMessage(message: ChatMessage): ChatMessage {
|
|
if (message.author === 'user') {
|
|
return message;
|
|
}
|
|
|
|
const existingParts = Array.isArray(message.parts) ? message.parts.filter(Boolean) : [];
|
|
const extracted = extractChatMessageParts(message.text);
|
|
const nextParts = existingParts.length > 0 ? existingParts : extracted.parts;
|
|
|
|
if (nextParts.length === 0) {
|
|
return existingParts.length === 0 ? message : { ...message, parts: existingParts };
|
|
}
|
|
|
|
return {
|
|
...message,
|
|
text: extracted.strippedText,
|
|
parts: nextParts,
|
|
};
|
|
}
|
|
|
|
function createChatQuestionOnlyNotificationPreview(questionText?: string | null, fallback?: string) {
|
|
const questionPreview = createChatNotificationPreview(questionText ?? '');
|
|
return questionPreview ? `질문: ${questionPreview}` : fallback ?? '';
|
|
}
|
|
|
|
function normalizeNotificationDetailText(text?: string | null) {
|
|
const normalized = String(text ?? '').trim();
|
|
return normalized || undefined;
|
|
}
|
|
|
|
export function collectOfflineNotificationClientIds(sessionClientId?: string | null, preferredClientIds?: string[]) {
|
|
const nextClientIds = new Set<string>();
|
|
|
|
for (const candidate of preferredClientIds ?? []) {
|
|
const normalized = String(candidate ?? '').trim();
|
|
|
|
if (normalized) {
|
|
nextClientIds.add(normalized);
|
|
}
|
|
}
|
|
|
|
const normalizedSessionClientId = String(sessionClientId ?? '').trim();
|
|
|
|
if (normalizedSessionClientId) {
|
|
nextClientIds.add(normalizedSessionClientId);
|
|
}
|
|
|
|
return [...nextClientIds];
|
|
}
|
|
|
|
export function filterInactiveOfflineNotificationClientIds(
|
|
clientIds: string[],
|
|
sessions: Iterable<ChatSessionState>,
|
|
isActive: (clientId: string, currentSessions: Iterable<ChatSessionState>) => boolean = isChatClientActivelyViewing,
|
|
) {
|
|
return clientIds.filter((clientId) => !isActive(clientId, sessions));
|
|
}
|
|
|
|
export function shouldSendOfflineChatNotification(options: {
|
|
receiveRoomNotifications?: boolean | null;
|
|
conversationNotifyOffline?: boolean | null;
|
|
}) {
|
|
if (options.receiveRoomNotifications === false) {
|
|
return false;
|
|
}
|
|
|
|
return options.conversationNotifyOffline === true;
|
|
}
|
|
|
|
function isPreparingChatReply(text?: string | null) {
|
|
const normalized = String(text ?? '').replace(/\s+/g, ' ').trim();
|
|
return normalized.startsWith('응답을 준비하고 있습니다');
|
|
}
|
|
|
|
function formatTime(date: Date) {
|
|
return new Intl.DateTimeFormat('sv-SE', {
|
|
timeZone: KST_TIME_ZONE,
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
hour: '2-digit',
|
|
minute: '2-digit',
|
|
second: '2-digit',
|
|
hour12: false,
|
|
})
|
|
.format(date)
|
|
.replace(',', '');
|
|
}
|
|
|
|
export function resolveResponseTimestamp(requestedAtMs?: number | null, nowMs = Date.now()) {
|
|
if (!Number.isFinite(requestedAtMs)) {
|
|
return formatTime(new Date(nowMs));
|
|
}
|
|
|
|
return formatTime(new Date(Math.max(nowMs, Number(requestedAtMs) + 1_000)));
|
|
}
|
|
|
|
function parseRequestedAtMs(value: string) {
|
|
const parsed = Date.parse(value);
|
|
return Number.isFinite(parsed) ? parsed : Date.now();
|
|
}
|
|
|
|
function formatKstDate(date = new Date()) {
|
|
return new Intl.DateTimeFormat('en-CA', {
|
|
timeZone: KST_TIME_ZONE,
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
}).format(date);
|
|
}
|
|
|
|
function createChatMessageId() {
|
|
chatMessageSequence = (chatMessageSequence + 1) % 1_000;
|
|
return Date.now() * 1_000 + chatMessageSequence;
|
|
}
|
|
|
|
function createMessage(author: ChatAuthor, text: string, clientRequestId?: string | null, parts?: ChatMessagePart[]): ChatMessage {
|
|
return {
|
|
id: createChatMessageId(),
|
|
author,
|
|
text,
|
|
timestamp: formatTime(new Date()),
|
|
clientRequestId: clientRequestId?.trim() || null,
|
|
parts: Array.isArray(parts) ? parts : [],
|
|
};
|
|
}
|
|
|
|
function createRequestId() {
|
|
return `chat-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
|
|
}
|
|
|
|
function hasAuthorizedChatSocketAccess(request: IncomingMessage, url: URL) {
|
|
const queryToken = url.searchParams.get('accessToken')?.trim();
|
|
const headerToken = Array.isArray(request.headers['x-access-token'])
|
|
? String(request.headers['x-access-token'][0] ?? '').trim()
|
|
: String(request.headers['x-access-token'] ?? '').trim();
|
|
|
|
return hasErrorLogViewAccessToken(queryToken || headerToken);
|
|
}
|
|
|
|
function hashRequestId(value: string) {
|
|
let hash = 0;
|
|
|
|
for (const character of value) {
|
|
hash = (hash * 31 + character.charCodeAt(0)) | 0;
|
|
}
|
|
|
|
return Math.abs(hash) + 1_000_000;
|
|
}
|
|
|
|
export function fitActivityLogLines(lines: string[]) {
|
|
const normalizedLines = lines.map((line) => line.trim()).filter(Boolean);
|
|
|
|
if (normalizedLines.length <= 1) {
|
|
return normalizedLines;
|
|
}
|
|
|
|
let startIndex = Math.max(0, normalizedLines.length - MAX_CHAT_ACTIVITY_MESSAGE_LINES);
|
|
let fittedLines = normalizedLines.slice(startIndex);
|
|
|
|
while (fittedLines.length > 1 && fittedLines.join('\n\n').length > MAX_CHAT_ACTIVITY_MESSAGE_CHARS) {
|
|
startIndex += 1;
|
|
fittedLines = normalizedLines.slice(startIndex);
|
|
}
|
|
|
|
return fittedLines;
|
|
}
|
|
|
|
export function createActivityLogMessage(requestId: string, lines: string[]) {
|
|
const normalizedRequestId = requestId.trim();
|
|
const fittedLines = fitActivityLogLines(lines);
|
|
const messageBody = fittedLines.length > 0 ? fittedLines.join('\n\n') : '활동 로그를 준비하고 있습니다.';
|
|
const messageText = `${CHAT_ACTIVITY_MESSAGE_PREFIX}\n${messageBody}`;
|
|
|
|
return createMessage('system', messageText, normalizedRequestId)
|
|
? {
|
|
id: hashRequestId(normalizedRequestId),
|
|
author: 'system' as const,
|
|
text: messageText,
|
|
timestamp: formatTime(new Date()),
|
|
clientRequestId: normalizedRequestId,
|
|
}
|
|
: null;
|
|
}
|
|
|
|
function shouldPersistMessageUpdate(message: ChatMessage) {
|
|
if (message.author === 'codex') {
|
|
return false;
|
|
}
|
|
|
|
return !String(message.text ?? '').startsWith(`${CHAT_ACTIVITY_MESSAGE_PREFIX}\n`);
|
|
}
|
|
|
|
function isSocketOpen(socket: WebSocket | null | undefined) {
|
|
return Boolean(socket && socket.readyState === SOCKET_READY_STATE_OPEN);
|
|
}
|
|
|
|
function closeSocketSafely(
|
|
logger: FastifyBaseLogger,
|
|
socket: WebSocket | null | undefined,
|
|
message: string,
|
|
code = 1000,
|
|
reason = 'replaced',
|
|
) {
|
|
if (!socket) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
socket.close(code, reason);
|
|
} catch (error) {
|
|
logger.warn(error, message);
|
|
}
|
|
}
|
|
|
|
function sendSocketEnvelope(
|
|
logger: FastifyBaseLogger,
|
|
socket: WebSocket | null | undefined,
|
|
envelope: ChatOutboundMessage,
|
|
message: string,
|
|
) {
|
|
const targetSocket = socket;
|
|
|
|
if (!targetSocket || targetSocket.readyState !== SOCKET_READY_STATE_OPEN) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
targetSocket.send(JSON.stringify(envelope));
|
|
return true;
|
|
} catch (error) {
|
|
logger.warn(error, message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
type ParsedPlanContext = {
|
|
planId: number | null;
|
|
workId: string | null;
|
|
previewUrl: string | null;
|
|
};
|
|
|
|
type PlanSnapshot = {
|
|
planId: number;
|
|
workId: string;
|
|
status: string;
|
|
note: string;
|
|
workerStatus: string | null;
|
|
issueTags: string[];
|
|
hasOpenIssues: boolean;
|
|
assignedBranch: string | null;
|
|
lastError: string | null;
|
|
latestActionNote: string | null;
|
|
latestIssue: {
|
|
tag: string;
|
|
message: string;
|
|
resolved: boolean;
|
|
} | null;
|
|
latestSourceWork: {
|
|
summary: string;
|
|
previewUrl: string | null;
|
|
changedFiles: string[];
|
|
} | null;
|
|
recentActionNotes: string[];
|
|
recentWorkSummaries: string[];
|
|
};
|
|
|
|
function truncateText(value: string | null | undefined, limit = 120) {
|
|
const normalized = String(value ?? '').replace(/\s+/g, ' ').trim();
|
|
|
|
if (!normalized) {
|
|
return '';
|
|
}
|
|
|
|
return normalized.length > limit ? `${normalized.slice(0, limit - 1)}…` : normalized;
|
|
}
|
|
|
|
function extractReferencedPlanId(input: string) {
|
|
const planIdMatch = input.match(/(?:planid=|#)(\d{1,9})/i) ?? input.match(/\bplan\s*(\d{1,9})\b/i);
|
|
const parsedPlanId = planIdMatch?.[1] ? Number(planIdMatch[1]) : NaN;
|
|
|
|
return Number.isInteger(parsedPlanId) && parsedPlanId > 0 ? parsedPlanId : null;
|
|
}
|
|
|
|
function extractReferencedWorkId(input: string) {
|
|
const workIdMatch = input.match(/\bworkid\s*[:=]?\s*([^\s,]+)/i);
|
|
return workIdMatch?.[1]?.trim() || null;
|
|
}
|
|
|
|
function extractReferencedPreviewUrl(input: string) {
|
|
const previewUrlMatch = input.match(/https?:\/\/[^\s)]+/i);
|
|
return previewUrlMatch?.[0]?.trim() || null;
|
|
}
|
|
|
|
function buildChangedFilesSummary(changedFiles: string[], limit = 5) {
|
|
if (changedFiles.length === 0) {
|
|
return '변경/신규 파일: 기록 없음';
|
|
}
|
|
|
|
const visibleFiles = changedFiles.slice(0, limit);
|
|
const suffix = changedFiles.length > limit ? ` 외 ${changedFiles.length - limit}개` : '';
|
|
return `변경/신규 파일: ${visibleFiles.join(', ')}${suffix}`;
|
|
}
|
|
|
|
function parsePlanContext(context: ChatContext | null, input: string): ParsedPlanContext {
|
|
const pageUrl = context?.pageUrl ?? '';
|
|
const referencedPlanId = extractReferencedPlanId(input);
|
|
const referencedWorkId = extractReferencedWorkId(input);
|
|
const referencedPreviewUrl = extractReferencedPreviewUrl(input);
|
|
|
|
if (!pageUrl) {
|
|
return {
|
|
planId: referencedPlanId,
|
|
workId: referencedWorkId,
|
|
previewUrl: referencedPreviewUrl,
|
|
};
|
|
}
|
|
|
|
try {
|
|
const url = new URL(pageUrl);
|
|
const planIdText = url.searchParams.get('planId');
|
|
const workIdText = url.searchParams.get('workId');
|
|
const planIdNumber = planIdText ? Number(planIdText) : NaN;
|
|
|
|
return {
|
|
planId: Number.isInteger(planIdNumber) && planIdNumber > 0 ? planIdNumber : referencedPlanId,
|
|
workId: workIdText?.trim() || referencedWorkId,
|
|
previewUrl: referencedPreviewUrl,
|
|
};
|
|
} catch {
|
|
return {
|
|
planId: referencedPlanId,
|
|
workId: referencedWorkId,
|
|
previewUrl: referencedPreviewUrl,
|
|
};
|
|
}
|
|
}
|
|
|
|
async function loadPlanSnapshot(planId: number): Promise<PlanSnapshot | null> {
|
|
const item = await getPlanItemById(planId);
|
|
|
|
if (!item) {
|
|
return null;
|
|
}
|
|
|
|
const [actionRows, issueRows, sourceWorkRows] = await Promise.all([
|
|
listPlanActionHistories(planId),
|
|
listPlanIssueHistories(planId),
|
|
listPlanSourceWorkHistories(planId),
|
|
]);
|
|
const latestAction = actionRows[0] ? mapPlanActionRow(actionRows[0]) : null;
|
|
const latestIssue = issueRows[0] ? mapPlanIssueRow(issueRows[0]) : null;
|
|
const latestSourceWork = sourceWorkRows[0] ? mapPlanSourceWorkRow(sourceWorkRows[0]) : null;
|
|
|
|
return {
|
|
planId,
|
|
workId: String(item.workId ?? '작업ID'),
|
|
status: String(item.status ?? '-'),
|
|
note: String(item.note ?? ''),
|
|
workerStatus: item.workerStatus ? String(item.workerStatus) : null,
|
|
issueTags: Array.isArray(item.issueTags) ? item.issueTags.map((value) => String(value)) : [],
|
|
hasOpenIssues: Boolean(item.hasOpenIssues),
|
|
assignedBranch: item.assignedBranch ? String(item.assignedBranch) : null,
|
|
lastError: item.lastError ? String(item.lastError) : null,
|
|
latestActionNote: latestAction ? String(latestAction.note) : null,
|
|
latestIssue: latestIssue
|
|
? {
|
|
tag: String(latestIssue.issueTag),
|
|
message: String(latestIssue.message),
|
|
resolved: Boolean(latestIssue.resolved),
|
|
}
|
|
: null,
|
|
latestSourceWork: latestSourceWork
|
|
? {
|
|
summary: String(latestSourceWork.summary),
|
|
previewUrl: latestSourceWork.previewUrl ? String(latestSourceWork.previewUrl) : null,
|
|
changedFiles: latestSourceWork.changedFiles,
|
|
}
|
|
: null,
|
|
recentActionNotes: actionRows
|
|
.slice(0, 5)
|
|
.map((row) => truncateText(String(mapPlanActionRow(row).note ?? ''), 140))
|
|
.filter(Boolean),
|
|
recentWorkSummaries: sourceWorkRows
|
|
.slice(0, 5)
|
|
.map((row) => truncateText(String(mapPlanSourceWorkRow(row).summary ?? ''), 140))
|
|
.filter(Boolean),
|
|
};
|
|
}
|
|
|
|
function isWorklogRequest(input: string) {
|
|
const normalized = input.toLowerCase();
|
|
const mentionsWorklog =
|
|
input.includes('워크일지') ||
|
|
input.includes('작업로그') ||
|
|
input.includes('작업 일지') ||
|
|
input.includes('작업일지') ||
|
|
normalized.includes('worklog');
|
|
const asksToWrite =
|
|
input.includes('작성') ||
|
|
input.includes('정리') ||
|
|
input.includes('기록') ||
|
|
input.includes('밀린') ||
|
|
input.includes('써');
|
|
|
|
return mentionsWorklog || (normalized.includes('log') && asksToWrite);
|
|
}
|
|
|
|
function isPlanDetailRequest(input: string) {
|
|
const normalized = input.toLowerCase();
|
|
|
|
return (
|
|
input.includes('작업') ||
|
|
input.includes('계획') ||
|
|
input.includes('이력') ||
|
|
input.includes('이슈') ||
|
|
input.includes('상태') ||
|
|
input.includes('브랜치') ||
|
|
normalized.includes('plan') ||
|
|
normalized.includes('issue') ||
|
|
normalized.includes('status') ||
|
|
normalized.includes('history') ||
|
|
normalized.includes('branch')
|
|
);
|
|
}
|
|
|
|
function buildWorklogReply(context: ChatContext | null, snapshot: PlanSnapshot | null) {
|
|
const pageTitle = context?.pageTitle ?? '현재 화면';
|
|
|
|
if (!snapshot) {
|
|
return `현재 화면: ${pageTitle}\n작업로그 초안을 만들 Plan을 찾지 못했습니다. Plan 상세를 연 뒤 다시 요청해 주세요.`;
|
|
}
|
|
|
|
const today = new Intl.DateTimeFormat('en-CA', {
|
|
timeZone: 'Asia/Seoul',
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
}).format(new Date());
|
|
const todayWork = [
|
|
truncateText(snapshot.note, 180),
|
|
...snapshot.recentWorkSummaries,
|
|
snapshot.latestActionNote ? truncateText(snapshot.latestActionNote, 140) : '',
|
|
].filter(Boolean);
|
|
const issues = snapshot.latestIssue
|
|
? [
|
|
`${snapshot.latestIssue.tag} ${snapshot.latestIssue.resolved ? '해결' : '미해결'}: ${truncateText(
|
|
snapshot.latestIssue.message,
|
|
140,
|
|
)}`,
|
|
]
|
|
: [];
|
|
const decisions = [
|
|
snapshot.assignedBranch ? `작업 브랜치: ${snapshot.assignedBranch}` : '',
|
|
snapshot.latestSourceWork?.previewUrl ? `preview 링크: ${snapshot.latestSourceWork.previewUrl}` : '',
|
|
snapshot.status ? `현재 상태: ${snapshot.status}${snapshot.workerStatus ? ` / ${snapshot.workerStatus}` : ''}` : '',
|
|
].filter(Boolean);
|
|
const details = [...snapshot.recentActionNotes, ...snapshot.recentWorkSummaries].filter(Boolean);
|
|
|
|
return [
|
|
`현재 화면: ${pageTitle}`,
|
|
`기준 Plan: #${snapshot.planId} ${snapshot.workId}`,
|
|
'아래 초안을 작업일지에 바로 붙여 넣으면 됩니다.',
|
|
'',
|
|
`# ${today} 작업일지`,
|
|
'',
|
|
'## 오늘 작업',
|
|
...(todayWork.length > 0 ? todayWork.slice(0, 6).map((item) => `- ${item}`) : ['- Plan 메모와 이력 확인 후 작업 내용을 보강해 주세요.']),
|
|
'',
|
|
'## 이슈 및 해결',
|
|
...(issues.length > 0 ? issues.map((item) => `- ${item}`) : ['- 현재 기록된 이슈 없음']),
|
|
'',
|
|
'## 결정 사항',
|
|
...(decisions.length > 0 ? decisions.map((item) => `- ${item}`) : ['- 별도 결정 사항 없음']),
|
|
'',
|
|
'## 상세 작업 내역',
|
|
...(details.length > 0 ? details.slice(0, 8).map((item) => `- ${item}`) : ['- 최근 조치 이력이 없어 상세 내역 보강이 필요합니다.']),
|
|
].join('\n');
|
|
}
|
|
|
|
function buildRecentPlanHistoryLines(snapshot: PlanSnapshot | null, limit = 2) {
|
|
if (!snapshot) {
|
|
return [];
|
|
}
|
|
|
|
const historyItems = [
|
|
...snapshot.recentActionNotes.map((note) => `[조치] ${note}`),
|
|
...snapshot.recentWorkSummaries.map((summary) => `[소스] ${summary}`),
|
|
]
|
|
.filter(Boolean)
|
|
.slice(0, limit);
|
|
|
|
if (historyItems.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
return ['최근 조치 이력:', ...historyItems.map((item, index) => `${index + 1}. ${item}`)];
|
|
}
|
|
|
|
function isDetailRequest(input: string) {
|
|
const normalized = input.toLowerCase();
|
|
|
|
return (
|
|
input.includes('상세') ||
|
|
input.includes('자세히') ||
|
|
input.includes('전체') ||
|
|
normalized.includes('detail') ||
|
|
normalized.includes('details') ||
|
|
normalized.includes('more')
|
|
);
|
|
}
|
|
|
|
export function isAutomationRegistrationCountRequest(input: string) {
|
|
const normalized = input.toLowerCase();
|
|
const mentionsAutomation =
|
|
input.includes('자동화') || normalized.includes('automation') || normalized.includes('plan');
|
|
const mentionsRegistration =
|
|
input.includes('등록') || input.includes('접수') || normalized.includes('register') || normalized.includes('count');
|
|
const mentionsToday =
|
|
input.includes('오늘') || normalized.includes('today');
|
|
const asksCount =
|
|
input.includes('총') ||
|
|
input.includes('건수') ||
|
|
input.includes('몇 건') ||
|
|
input.includes('몇건') ||
|
|
normalized.includes('count') ||
|
|
normalized.includes('total');
|
|
|
|
return mentionsAutomation && mentionsRegistration && (mentionsToday || asksCount);
|
|
}
|
|
|
|
function isAutomationRegistrationDefinitionRequest(input: string) {
|
|
const normalized = input.toLowerCase();
|
|
const mentionsAutomation = input.includes('자동화') || normalized.includes('automation');
|
|
const mentionsRegistration = input.includes('등록') || input.includes('접수') || normalized.includes('register');
|
|
const asksMeaning =
|
|
input.includes('무슨 뜻') ||
|
|
input.includes('뭐야') ||
|
|
input.includes('뜻') ||
|
|
input.includes('기준') ||
|
|
input.includes('뭘 의미') ||
|
|
normalized.includes('meaning') ||
|
|
normalized.includes('define');
|
|
|
|
return mentionsAutomation && mentionsRegistration && asksMeaning;
|
|
}
|
|
|
|
export function shouldUseAgenticCodexReply(input: string) {
|
|
const normalized = input.toLowerCase();
|
|
const trimmed = input.trim();
|
|
|
|
if (isAutomationRegistrationCountRequest(input) || isAutomationRegistrationDefinitionRequest(input)) {
|
|
return false;
|
|
}
|
|
|
|
if (!trimmed) {
|
|
return false;
|
|
}
|
|
|
|
if (trimmed.length <= 3 && !/(db|api|fix|bug|log|sql)/i.test(trimmed)) {
|
|
return false;
|
|
}
|
|
|
|
if (isDetailRequest(input) || isPlanDetailRequest(input) || isWorklogRequest(input)) {
|
|
return false;
|
|
}
|
|
|
|
return (
|
|
input.includes('수정') ||
|
|
input.includes('변경') ||
|
|
input.includes('구현') ||
|
|
input.includes('추가') ||
|
|
input.includes('삭제') ||
|
|
input.includes('고쳐') ||
|
|
input.includes('만들어') ||
|
|
input.includes('등록해줘') ||
|
|
input.includes('조회') ||
|
|
input.includes('확인') ||
|
|
input.includes('읽어') ||
|
|
input.includes('분석') ||
|
|
input.includes('DB') ||
|
|
input.includes('API') ||
|
|
input.includes('소스') ||
|
|
input.includes('파일') ||
|
|
input.includes('로그') ||
|
|
/(?:\/|\\).+\.[a-z0-9]+/i.test(input) ||
|
|
normalized.includes('fix') ||
|
|
normalized.includes('implement') ||
|
|
normalized.includes('change') ||
|
|
normalized.includes('edit') ||
|
|
normalized.includes('read') ||
|
|
normalized.includes('source') ||
|
|
normalized.includes('file') ||
|
|
normalized.includes('db') ||
|
|
normalized.includes('api') ||
|
|
/\s/.test(trimmed)
|
|
);
|
|
}
|
|
|
|
export function shouldUseTemplateMacroReply(context: ChatContext | null, input: string) {
|
|
void context;
|
|
void input;
|
|
return false;
|
|
}
|
|
|
|
function summarizeCodexOutput(output: string) {
|
|
const normalized = String(output ?? '').trim();
|
|
|
|
if (!normalized) {
|
|
return 'Codex 실행 결과가 비어 있습니다.';
|
|
}
|
|
|
|
const lines = normalized
|
|
.split('\n')
|
|
.map((line) => line.trimEnd())
|
|
.filter(Boolean);
|
|
|
|
return lines.slice(-12).join('\n');
|
|
}
|
|
|
|
class ChatRuntimeExecutionError extends Error {
|
|
responseText: string;
|
|
|
|
constructor(message: string, responseText = '') {
|
|
super(message);
|
|
this.name = 'ChatRuntimeExecutionError';
|
|
this.responseText = responseText.trim();
|
|
}
|
|
}
|
|
|
|
function summarizeCommand(command: string, limit = 180) {
|
|
const normalized = String(command ?? '').replace(/\s+/g, ' ').trim();
|
|
|
|
if (!normalized) {
|
|
return '';
|
|
}
|
|
|
|
return normalized.length > limit ? `${normalized.slice(0, limit - 1).trimEnd()}...` : normalized;
|
|
}
|
|
|
|
function summarizeCommandOutput(output: string, maxLines = 3, maxLength = 220) {
|
|
const lines = String(output ?? '')
|
|
.replace(/\r/g, '')
|
|
.split('\n')
|
|
.map((line) => line.trim())
|
|
.filter(Boolean);
|
|
|
|
if (lines.length === 0) {
|
|
return '';
|
|
}
|
|
|
|
const joined = lines.slice(0, maxLines).join(' / ');
|
|
return joined.length > maxLength ? `${joined.slice(0, maxLength - 1).trimEnd()}...` : joined;
|
|
}
|
|
|
|
function inferCommandReason(command: string) {
|
|
const normalized = command.toLowerCase();
|
|
|
|
if (normalized.includes('rg ') || normalized.includes('ripgrep')) {
|
|
return '관련 파일이나 텍스트를 빠르게 찾기 위해 검색했습니다.';
|
|
}
|
|
|
|
if (normalized.includes('sed -n') || normalized.includes('cat ') || normalized.includes('less ')) {
|
|
return '해당 파일 내용을 직접 읽어 문맥을 확인했습니다.';
|
|
}
|
|
|
|
if (normalized.includes('ls ') || normalized === 'ls' || normalized.includes('rg --files')) {
|
|
return '디렉터리 구조와 대상 파일 위치를 확인했습니다.';
|
|
}
|
|
|
|
if (normalized.includes('git status')) {
|
|
return '작업 트리 상태와 변경 범위를 점검했습니다.';
|
|
}
|
|
|
|
if (normalized.includes('tsc ') || normalized.includes('npm test') || normalized.includes('node --test')) {
|
|
return '수정 후 타입이나 동작 검증을 진행했습니다.';
|
|
}
|
|
|
|
if (normalized.includes('curl ') || normalized.includes('fetch')) {
|
|
return '실제 응답이나 연결 상태를 확인했습니다.';
|
|
}
|
|
|
|
return '현재 요청을 해결하기 위한 다음 단계를 확인했습니다.';
|
|
}
|
|
|
|
function isIgnorableCodexDiagnosticLine(line: string) {
|
|
const normalized = line.trim();
|
|
|
|
if (!normalized) {
|
|
return true;
|
|
}
|
|
|
|
return (
|
|
/^\d{4}-\d{2}-\d{2}T\S+\s+WARN\b/.test(normalized) ||
|
|
normalized.includes('ignoring interface.defaultPrompt') ||
|
|
normalized.includes('failed to open state db') ||
|
|
normalized.includes('state db discrepancy') ||
|
|
normalized.includes('Failed to kill MCP process group') ||
|
|
normalized.includes('Failed to delete shell snapshot') ||
|
|
normalized.includes('failed to unwatch ')
|
|
);
|
|
}
|
|
|
|
function extractCodexActivityLog(parsed: Record<string, unknown>) {
|
|
const type = typeof parsed.type === 'string' ? parsed.type : '';
|
|
const item = parsed.item && typeof parsed.item === 'object' ? (parsed.item as Record<string, unknown>) : null;
|
|
const itemType = typeof item?.type === 'string' ? item.type : '';
|
|
|
|
if (!item || itemType !== 'command_execution') {
|
|
return '';
|
|
}
|
|
|
|
const command = summarizeCommand(typeof item.command === 'string' ? item.command : '');
|
|
|
|
if (!command) {
|
|
return '';
|
|
}
|
|
|
|
const reason = inferCommandReason(command);
|
|
|
|
if (type === 'item.started') {
|
|
return `# 이유: ${reason}\n$ ${command}`;
|
|
}
|
|
|
|
if (type === 'item.completed') {
|
|
const exitCode =
|
|
typeof item.exit_code === 'number' && Number.isFinite(item.exit_code) ? Math.round(item.exit_code) : null;
|
|
const outputSummary = summarizeCommandOutput(typeof item.aggregated_output === 'string' ? item.aggregated_output : '');
|
|
const statusLabel = exitCode === null ? '# 결과: 완료' : exitCode === 0 ? '# 결과: 완료(0)' : `# 결과: 종료(${exitCode})`;
|
|
|
|
return outputSummary ? `${statusLabel}\n# 출력: ${outputSummary}` : statusLabel;
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
function normalizeCodexReplyOutput(output: string) {
|
|
const normalized = String(output ?? '').trim();
|
|
return normalized || 'Codex 실행 결과가 비어 있습니다.';
|
|
}
|
|
|
|
function collectCodexTextFragments(value: unknown): string[] {
|
|
if (typeof value === 'string') {
|
|
const normalized = value.trim();
|
|
return normalized ? [normalized] : [];
|
|
}
|
|
|
|
if (Array.isArray(value)) {
|
|
return value.flatMap((item) => collectCodexTextFragments(item));
|
|
}
|
|
|
|
if (!value || typeof value !== 'object') {
|
|
return [];
|
|
}
|
|
|
|
const record = value as Record<string, unknown>;
|
|
const directTextKeys = ['text', 'delta', 'output_text', 'content', 'message'];
|
|
|
|
for (const key of directTextKeys) {
|
|
const fragments = collectCodexTextFragments(record[key]);
|
|
|
|
if (fragments.length > 0) {
|
|
return fragments;
|
|
}
|
|
}
|
|
|
|
if (typeof record.type === 'string' && record.type.includes('output_text')) {
|
|
const fragments = collectCodexTextFragments(record.text ?? record.delta);
|
|
|
|
if (fragments.length > 0) {
|
|
return fragments;
|
|
}
|
|
}
|
|
|
|
return Object.values(record).flatMap((item) => collectCodexTextFragments(item));
|
|
}
|
|
|
|
function extractCompletedAgentMessageText(item: unknown) {
|
|
if (!item || typeof item !== 'object') {
|
|
return '';
|
|
}
|
|
|
|
const record = item as Record<string, unknown>;
|
|
|
|
if (record.type !== 'agent_message') {
|
|
return '';
|
|
}
|
|
|
|
return collectCodexTextFragments(record.text ?? record.content ?? record.message).join('');
|
|
}
|
|
|
|
export function extractCodexStreamText(parsed: Record<string, unknown>) {
|
|
const type = typeof parsed.type === 'string' ? parsed.type : '';
|
|
|
|
if (type === 'item.completed') {
|
|
const completedText = extractCompletedAgentMessageText(parsed.item);
|
|
return {
|
|
type,
|
|
completedText,
|
|
deltaText: '',
|
|
};
|
|
}
|
|
|
|
if (type === 'item.delta' || type === 'response.output_text.delta') {
|
|
const deltaText =
|
|
type === 'response.output_text.delta'
|
|
? collectCodexTextFragments(parsed.delta ?? parsed.text).join('')
|
|
: collectCodexTextFragments(parsed.delta).join('');
|
|
return {
|
|
type,
|
|
completedText: '',
|
|
deltaText,
|
|
};
|
|
}
|
|
|
|
if (type === 'response.completed') {
|
|
const completedText = collectCodexTextFragments(parsed.response).join('');
|
|
return {
|
|
type,
|
|
completedText,
|
|
deltaText: '',
|
|
};
|
|
}
|
|
|
|
return {
|
|
type,
|
|
completedText: '',
|
|
deltaText: '',
|
|
};
|
|
}
|
|
|
|
export function parseStructuredCodexStdoutLine(line: string) {
|
|
const normalizedLine = String(line ?? '').trim();
|
|
|
|
if (!normalizedLine) {
|
|
return {
|
|
activityLog: '',
|
|
completedText: '',
|
|
deltaText: '',
|
|
shouldKeepRaw: false,
|
|
};
|
|
}
|
|
|
|
let parsed: Record<string, unknown>;
|
|
|
|
try {
|
|
parsed = JSON.parse(normalizedLine) as Record<string, unknown>;
|
|
} catch {
|
|
return {
|
|
activityLog: '',
|
|
completedText: '',
|
|
deltaText: '',
|
|
shouldKeepRaw: true,
|
|
};
|
|
}
|
|
|
|
const activityLog = extractCodexActivityLog(parsed);
|
|
const streamText = extractCodexStreamText(parsed);
|
|
const shouldKeepRaw = !activityLog && !streamText.completedText && !streamText.deltaText;
|
|
|
|
return {
|
|
activityLog,
|
|
completedText: streamText.completedText,
|
|
deltaText: streamText.deltaText,
|
|
shouldKeepRaw,
|
|
};
|
|
}
|
|
|
|
async function streamReplyChunks(text: string, onProgress?: (text: string) => void, chunkSize = 28, delayMs = 24) {
|
|
const normalized = normalizeCodexReplyOutput(text);
|
|
|
|
if (!onProgress) {
|
|
return normalized;
|
|
}
|
|
|
|
for (let index = chunkSize; index < normalized.length; index += chunkSize) {
|
|
onProgress(normalized.slice(0, index));
|
|
await new Promise((resolve) => {
|
|
setTimeout(resolve, delayMs);
|
|
});
|
|
}
|
|
|
|
onProgress(normalized);
|
|
return normalized;
|
|
}
|
|
|
|
function escapeRegExp(value: string) {
|
|
return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
}
|
|
|
|
function stripTrailingLineInfo(value: string) {
|
|
return value.replace(/:\d+(?::\d+)?$/, '');
|
|
}
|
|
|
|
function trimPathCandidate(value: string) {
|
|
return value.replace(/^[("'`\[]+/, '').replace(/[)\]"'`,.;:]+$/, '');
|
|
}
|
|
|
|
function encodeUrlPathSegments(value: string) {
|
|
return value
|
|
.split('/')
|
|
.filter(Boolean)
|
|
.map((segment) => encodeURIComponent(segment))
|
|
.join('/');
|
|
}
|
|
|
|
const CHAT_RESOURCE_REPO_RELATIVE_PATH_PATTERN =
|
|
/^(?:src|public|docs|etc|scripts|\.github)\/[^\n\s)\]"'`,]+$/;
|
|
const CHAT_RESOURCE_ROOT_FILE_PATTERN =
|
|
/^(?:docker-compose\.(?:yml|yaml)|[A-Za-z0-9._-]*Dockerfile(?:\.[A-Za-z0-9._-]+)?|(?:AGENTS|README)(?:\.[A-Za-z0-9._-]+)?|package(?:-lock)?\.json|tsconfig(?:\.[A-Za-z0-9._-]+)?\.json|vite\.config\.[A-Za-z0-9._-]+|eslint\.config\.[A-Za-z0-9._-]+|prettier\.config\.[A-Za-z0-9._-]+|pnpm-lock\.yaml|yarn\.lock|bun\.lockb|npm-shrinkwrap\.json|\.env(?:\.[A-Za-z0-9._-]+)?|\.gitignore|\.dockerignore)$/;
|
|
|
|
function isLikelyRepoRelativeChatResourcePath(candidate: string) {
|
|
const normalized = candidate.replace(/^\/+/, '');
|
|
return (
|
|
CHAT_RESOURCE_REPO_RELATIVE_PATH_PATTERN.test(normalized) ||
|
|
CHAT_RESOURCE_ROOT_FILE_PATTERN.test(normalized)
|
|
);
|
|
}
|
|
|
|
function buildChatResourcePublicUrl(relativePath: string) {
|
|
const cleaned = relativePath.replace(/^public\//, '').replace(/^\/+/, '');
|
|
return `${CHAT_API_RESOURCE_ROUTE_PREFIX}/${encodeUrlPathSegments(cleaned)}`;
|
|
}
|
|
|
|
function normalizeEmbeddedChatResourceUrls(text: string) {
|
|
return String(text ?? '')
|
|
.replace(/https?:\/(api\/chat\/resources\/\.codex_chat\/[^\s)\]"'`,]+)/gi, '/$1')
|
|
.replace(
|
|
/(?:\/[^\s)\]"'`,]*?)?(\/api\/chat\/resources\/\.codex_chat\/[^\s)\]"'`,]+)/g,
|
|
(_match, resourcePath) => resourcePath,
|
|
);
|
|
}
|
|
|
|
function toPosixPath(value: string) {
|
|
return value.split(path.sep).join('/');
|
|
}
|
|
|
|
function normalizeExistingChatPublicUrl(candidate: string) {
|
|
const cleaned = stripTrailingLineInfo(trimPathCandidate(candidate.trim()))
|
|
.replace(/^\/+/, '')
|
|
.replace(/^public\//, '');
|
|
|
|
if (!cleaned.startsWith(`${CHAT_PUBLIC_RESOURCE_DIR}/`)) {
|
|
return null;
|
|
}
|
|
|
|
return buildChatResourcePublicUrl(cleaned);
|
|
}
|
|
|
|
export function extractDiffCodeBlocks(output: string) {
|
|
const matches = Array.from(String(output ?? '').matchAll(/```diff[^\n]*\n([\s\S]*?)\n```/g));
|
|
|
|
return matches
|
|
.map((match) => (typeof match[1] === 'string' ? match[1].trim() : ''))
|
|
.filter(Boolean);
|
|
}
|
|
|
|
function protectDiffCodeBlocks(output: string) {
|
|
const blocks: string[] = [];
|
|
const text = String(output ?? '').replace(/```diff[^\n]*\n[\s\S]*?\n```/g, (match) => {
|
|
const token = `__CODEX_DIFF_BLOCK_${blocks.length}__`;
|
|
blocks.push(match);
|
|
return token;
|
|
});
|
|
|
|
return { text, blocks };
|
|
}
|
|
|
|
function restoreDiffCodeBlocks(output: string, blocks: string[]) {
|
|
return blocks.reduce(
|
|
(current, block, index) => current.replace(`__CODEX_DIFF_BLOCK_${index}__`, block),
|
|
String(output ?? ''),
|
|
);
|
|
}
|
|
|
|
async function resolveChatResourceSourcePath(repoPath: string, candidate: string) {
|
|
const cleaned = stripTrailingLineInfo(trimPathCandidate(candidate.trim()));
|
|
|
|
if (!cleaned) {
|
|
return null;
|
|
}
|
|
|
|
let sourcePath: string | null = null;
|
|
|
|
if (cleaned.startsWith(repoPath)) {
|
|
sourcePath = cleaned;
|
|
} else if (cleaned.startsWith('/')) {
|
|
if (isLikelyRepoRelativeChatResourcePath(cleaned)) {
|
|
sourcePath = path.resolve(repoPath, cleaned.replace(/^\/+/, ''));
|
|
} else {
|
|
sourcePath = cleaned;
|
|
}
|
|
} else {
|
|
sourcePath = path.resolve(repoPath, cleaned);
|
|
}
|
|
|
|
const normalizedRepoPath = path.resolve(repoPath);
|
|
const normalizedSourcePath = path.resolve(sourcePath);
|
|
const relativePath = path.relative(normalizedRepoPath, normalizedSourcePath);
|
|
|
|
if (!relativePath || relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const sourceStat = await stat(normalizedSourcePath);
|
|
|
|
if (!sourceStat.isFile()) {
|
|
return null;
|
|
}
|
|
} catch {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
absolutePath: normalizedSourcePath,
|
|
relativePath: toPosixPath(relativePath),
|
|
};
|
|
}
|
|
|
|
export function isChatResourcePathCandidate(candidate: string) {
|
|
const cleaned = stripTrailingLineInfo(trimPathCandidate(candidate.trim()));
|
|
|
|
if (!cleaned) {
|
|
return false;
|
|
}
|
|
|
|
if (cleaned.startsWith(`/${CHAT_PUBLIC_RESOURCE_DIR}/`)) {
|
|
return true;
|
|
}
|
|
|
|
return isLikelyRepoRelativeChatResourcePath(cleaned) || /^\/(?:workspace|root|home|Users|tmp)\//.test(cleaned);
|
|
}
|
|
|
|
export async function stageChatResourceFile(repoPath: string, sessionId: string, candidate: string) {
|
|
const existingPublicUrl = normalizeExistingChatPublicUrl(candidate);
|
|
|
|
if (existingPublicUrl) {
|
|
return existingPublicUrl;
|
|
}
|
|
|
|
const resolvedSource = await resolveChatResourceSourcePath(repoPath, candidate);
|
|
|
|
if (!resolvedSource) {
|
|
return null;
|
|
}
|
|
|
|
await ensureChatSessionResourceDirectories(repoPath, sessionId);
|
|
const targetRelativePath = `${CHAT_PUBLIC_RESOURCE_DIR}/${sessionId}/${CHAT_PUBLIC_RESOURCE_SUBDIR}/${resolvedSource.relativePath}`;
|
|
const targetAbsolutePath = path.join(repoPath, 'public', targetRelativePath);
|
|
await mkdir(path.dirname(targetAbsolutePath), { recursive: true });
|
|
await cp(resolvedSource.absolutePath, targetAbsolutePath, { force: true });
|
|
|
|
return buildChatResourcePublicUrl(targetRelativePath);
|
|
}
|
|
|
|
async function stageChatDiffResourceFiles(repoPath: string, sessionId: string, output: string) {
|
|
const diffBlocks = extractDiffCodeBlocks(output);
|
|
|
|
if (diffBlocks.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
const urls: string[] = [];
|
|
await ensureChatSessionResourceDirectories(repoPath, sessionId);
|
|
|
|
for (const [index, diffText] of diffBlocks.entries()) {
|
|
const fileName = diffBlocks.length === 1 ? 'response.diff' : `response-${index + 1}.diff`;
|
|
const targetRelativePath =
|
|
`${CHAT_PUBLIC_RESOURCE_DIR}/${sessionId}/${CHAT_PUBLIC_RESOURCE_SUBDIR}/_generated/${fileName}`;
|
|
const targetAbsolutePath = path.join(repoPath, 'public', targetRelativePath);
|
|
await mkdir(path.dirname(targetAbsolutePath), { recursive: true });
|
|
await writeFile(targetAbsolutePath, `${diffText}\n`, 'utf8');
|
|
urls.push(buildChatResourcePublicUrl(targetRelativePath));
|
|
}
|
|
|
|
return urls;
|
|
}
|
|
|
|
async function ensureWorldWritableDirectory(absolutePath: string) {
|
|
await mkdir(absolutePath, { recursive: true, mode: CHAT_SESSION_RESOURCE_DIR_MODE });
|
|
await chmod(absolutePath, CHAT_SESSION_RESOURCE_DIR_MODE).catch(() => {});
|
|
}
|
|
|
|
export async function ensureChatSessionResourceDirectories(repoPath: string, sessionId: string) {
|
|
const sessionRoot = path.join(repoPath, 'public', CHAT_PUBLIC_RESOURCE_DIR, sessionId);
|
|
const resourceRoot = path.join(sessionRoot, CHAT_PUBLIC_RESOURCE_SUBDIR);
|
|
const sourceRoot = path.join(resourceRoot, 'source');
|
|
const uploadRoot = path.join(resourceRoot, 'uploads');
|
|
|
|
await ensureWorldWritableDirectory(sessionRoot);
|
|
await ensureWorldWritableDirectory(resourceRoot);
|
|
await ensureWorldWritableDirectory(sourceRoot);
|
|
await ensureWorldWritableDirectory(uploadRoot);
|
|
|
|
return {
|
|
sessionRoot,
|
|
resourceRoot,
|
|
sourceRoot,
|
|
uploadRoot,
|
|
};
|
|
}
|
|
|
|
function appendDiffResourceLinks(output: string, diffUrls: string[]) {
|
|
if (diffUrls.length === 0) {
|
|
return output;
|
|
}
|
|
|
|
const uniqueUrls = diffUrls.filter((url, index) => diffUrls.indexOf(url) === index && !output.includes(url));
|
|
|
|
if (uniqueUrls.length === 0) {
|
|
return output;
|
|
}
|
|
|
|
const hiddenPreviewTags = uniqueUrls.map((url) => `[[preview:${url}]]`).join('\n');
|
|
return `${output}\n\n${hiddenPreviewTags}`;
|
|
}
|
|
|
|
function isPreviewEligibleChatResourceUrl(url: string) {
|
|
const pathname = url.split('?')[0]?.toLowerCase() ?? '';
|
|
return /\.(?:png|jpe?g|gif|webp|svg|bmp|ico|mp4|webm|mov|m4v|ogg|pdf|html?)$/i.test(pathname);
|
|
}
|
|
|
|
function resolveChatResourcePublicUrlToAbsolutePath(repoPath: string, url: string) {
|
|
const normalizedUrl = normalizeEmbeddedChatResourceUrls(url).trim();
|
|
const relativeUrl = normalizedUrl.replace(/^\/+/, '');
|
|
const routePrefix = `${CHAT_API_RESOURCE_ROUTE_PREFIX.replace(/^\/+/, '')}/`;
|
|
|
|
if (!relativeUrl.startsWith(routePrefix)) {
|
|
return null;
|
|
}
|
|
|
|
const encodedResourcePath = relativeUrl.slice(routePrefix.length);
|
|
|
|
try {
|
|
const decodedPath = encodedResourcePath
|
|
.split('/')
|
|
.filter(Boolean)
|
|
.map((segment) => decodeURIComponent(segment))
|
|
.join('/');
|
|
|
|
if (!decodedPath.startsWith(`${CHAT_PUBLIC_RESOURCE_DIR}/`)) {
|
|
return null;
|
|
}
|
|
|
|
return path.resolve(repoPath, 'public', decodedPath);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async function doesChatResourceUrlExist(repoPath: string, url: string) {
|
|
const absolutePath = resolveChatResourcePublicUrlToAbsolutePath(repoPath, url);
|
|
|
|
if (!absolutePath) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
const fileStat = await stat(absolutePath);
|
|
return fileStat.isFile();
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function sanitizeChatResourcePresentation(output: string, repoPath: string) {
|
|
let sanitized = normalizeEmbeddedChatResourceUrls(output);
|
|
const previewMatches = Array.from(sanitized.matchAll(/\[\[preview:([^\]\n]+)\]\]/gi));
|
|
const previewReplacementMap = new Map<string, string>();
|
|
|
|
for (const match of previewMatches) {
|
|
const marker = match[0] ?? '';
|
|
const rawUrl = match[1]?.trim() ?? '';
|
|
|
|
if (!marker || previewReplacementMap.has(marker)) {
|
|
continue;
|
|
}
|
|
|
|
const normalizedUrl = normalizeEmbeddedChatResourceUrls(rawUrl);
|
|
const exists = await doesChatResourceUrlExist(repoPath, normalizedUrl);
|
|
const keepMarker = exists && isPreviewEligibleChatResourceUrl(normalizedUrl);
|
|
previewReplacementMap.set(marker, keepMarker ? `[[preview:${normalizedUrl}]]` : '');
|
|
}
|
|
|
|
for (const [source, target] of previewReplacementMap.entries()) {
|
|
sanitized = sanitized.replaceAll(source, target);
|
|
}
|
|
|
|
return sanitized.replace(/\n{3,}/g, '\n\n').trim();
|
|
}
|
|
|
|
export async function rewriteCodexOutputWithChatResources(output: string, repoPath: string, sessionId: string) {
|
|
const { text: outputWithoutDiffBlocks, blocks: diffBlocks } = protectDiffCodeBlocks(output);
|
|
const escapedRepoPath = escapeRegExp(path.resolve(repoPath));
|
|
const filePathPattern = "[^\\n\\s)\\]\"'`,]+";
|
|
const rootFilePattern = String.raw`\/?(?:docker-compose\.(?:yml|yaml)|[A-Za-z0-9._-]*Dockerfile(?:\.[A-Za-z0-9._-]+)?|(?:AGENTS|README)(?:\.[A-Za-z0-9._-]+)?|package(?:-lock)?\.json|tsconfig(?:\.[A-Za-z0-9._-]+)?\.json|vite\.config\.[A-Za-z0-9._-]+|eslint\.config\.[A-Za-z0-9._-]+|prettier\.config\.[A-Za-z0-9._-]+|pnpm-lock\.yaml|yarn\.lock|bun\.lockb|npm-shrinkwrap\.json|\.env(?:\.[A-Za-z0-9._-]+)?|\.gitignore|\.dockerignore)`;
|
|
const candidatePattern = new RegExp(
|
|
`${escapedRepoPath}\\/${filePathPattern}|(?:\\/?(?:public\\/)?\\.codex_chat|src|public|docs|etc|scripts)\\/${filePathPattern}|${rootFilePattern}`,
|
|
'g',
|
|
);
|
|
const matches = [...outputWithoutDiffBlocks.matchAll(candidatePattern)];
|
|
let rewrittenOutput = outputWithoutDiffBlocks;
|
|
if (matches.length > 0) {
|
|
const replacementMap = new Map<string, string>();
|
|
|
|
for (const match of matches) {
|
|
const rawCandidate = match[0]?.trim();
|
|
|
|
if (!rawCandidate || replacementMap.has(rawCandidate)) {
|
|
continue;
|
|
}
|
|
|
|
const stagedUrl = await stageChatResourceFile(repoPath, sessionId, rawCandidate);
|
|
|
|
if (stagedUrl) {
|
|
replacementMap.set(rawCandidate, stagedUrl);
|
|
}
|
|
}
|
|
|
|
const replacements = Array.from(replacementMap.entries()).sort((left, right) => right[0].length - left[0].length);
|
|
|
|
for (const [sourcePath, publicUrl] of replacements) {
|
|
rewrittenOutput = rewrittenOutput.replaceAll(sourcePath, publicUrl);
|
|
}
|
|
}
|
|
|
|
rewrittenOutput = await sanitizeChatResourcePresentation(rewrittenOutput, repoPath);
|
|
rewrittenOutput = restoreDiffCodeBlocks(rewrittenOutput, diffBlocks);
|
|
|
|
const diffUrls = await stageChatDiffResourceFiles(repoPath, sessionId, output);
|
|
return sanitizeChatResourcePresentation(appendDiffResourceLinks(rewrittenOutput, diffUrls), repoPath);
|
|
}
|
|
|
|
function normalizeChatPromptHistoryText(text: string) {
|
|
return String(text ?? '').replace(/\s+/g, ' ').trim();
|
|
}
|
|
|
|
function normalizePromptHistoryMessageLimit(value: number | undefined) {
|
|
if (value === undefined || !Number.isFinite(value)) {
|
|
return CHAT_PROMPT_HISTORY_MAX_MESSAGES;
|
|
}
|
|
|
|
return Math.min(50, Math.max(1, Math.round(value)));
|
|
}
|
|
|
|
function normalizePromptHistoryCharLimit(value: number | undefined) {
|
|
if (value === undefined || !Number.isFinite(value)) {
|
|
return CHAT_PROMPT_HISTORY_MAX_CHARS;
|
|
}
|
|
|
|
return Math.min(20_000, Math.max(500, Math.round(value)));
|
|
}
|
|
|
|
async function buildRecentChatPromptHistory(
|
|
sessionId: string,
|
|
requestId: string,
|
|
limits?: {
|
|
maxMessages?: number;
|
|
maxChars?: number;
|
|
disabled?: boolean;
|
|
},
|
|
) {
|
|
if (limits?.disabled) {
|
|
return {
|
|
items: [],
|
|
omittedCount: 0,
|
|
};
|
|
}
|
|
|
|
const maxMessages = normalizePromptHistoryMessageLimit(limits?.maxMessages);
|
|
const maxChars = normalizePromptHistoryCharLimit(limits?.maxChars);
|
|
const messages = await listChatConversationMessages(sessionId, { limit: 80 });
|
|
const relevantMessages = messages.filter((message: (typeof messages)[number]) => {
|
|
if (message.clientRequestId?.trim() === requestId.trim()) {
|
|
return false;
|
|
}
|
|
|
|
if (message.author !== 'user' && message.author !== 'codex') {
|
|
return false;
|
|
}
|
|
|
|
return Boolean(normalizeChatPromptHistoryText(message.text));
|
|
});
|
|
|
|
const selectedMessages: typeof relevantMessages = [];
|
|
let totalChars = 0;
|
|
|
|
for (let index = relevantMessages.length - 1; index >= 0; index -= 1) {
|
|
const message = relevantMessages[index];
|
|
const text = normalizeChatPromptHistoryText(message.text);
|
|
const nextChars = text.length;
|
|
|
|
if (
|
|
selectedMessages.length >= maxMessages ||
|
|
(selectedMessages.length > 0 && totalChars + nextChars > maxChars)
|
|
) {
|
|
break;
|
|
}
|
|
|
|
selectedMessages.unshift(message);
|
|
totalChars += nextChars;
|
|
}
|
|
|
|
return {
|
|
items: selectedMessages.map(
|
|
(message: (typeof selectedMessages)[number]) => `[${message.author}] ${normalizeChatPromptHistoryText(message.text)}`,
|
|
),
|
|
omittedCount: Math.max(0, relevantMessages.length - selectedMessages.length),
|
|
};
|
|
}
|
|
|
|
function cloneChatContext(context: ChatContext | null): ChatContext | null {
|
|
return context ? { ...context } : null;
|
|
}
|
|
|
|
function resolvePromptChatTypeLabel(context: ChatContext | null) {
|
|
return context?.chatTypeLabel?.trim() || '';
|
|
}
|
|
|
|
function normalizeChatContextIdList(ids?: string[] | null) {
|
|
if (!Array.isArray(ids)) {
|
|
return [];
|
|
}
|
|
|
|
return Array.from(
|
|
new Set(
|
|
ids
|
|
.map((id) => id?.trim() || '')
|
|
.filter(Boolean),
|
|
),
|
|
);
|
|
}
|
|
|
|
function normalizeChatContextEntries(
|
|
entries: ChatContext['defaultContexts'],
|
|
): Array<{ id: string; title: string; content: string }> {
|
|
if (!Array.isArray(entries)) {
|
|
return [];
|
|
}
|
|
|
|
return entries
|
|
.map((entry) => ({
|
|
id: entry?.id?.trim() || '',
|
|
title: entry?.title?.trim() || '',
|
|
content: entry?.content?.trim() || '',
|
|
}))
|
|
.filter((entry) => entry.content);
|
|
}
|
|
|
|
function buildStructuredChatContextSections(context: ChatContext | null) {
|
|
const sections: string[] = [];
|
|
const baseDescription = context?.chatTypeBaseDescription?.trim() || '';
|
|
const defaultContexts = normalizeChatContextEntries(context?.defaultContexts);
|
|
const customContextTitle = context?.customContextTitle?.trim() || '';
|
|
const customContextContent = context?.customContextContent?.trim() || '';
|
|
|
|
if (baseDescription) {
|
|
sections.push(['## 채팅 유형 context 원문', baseDescription].join('\n'));
|
|
}
|
|
|
|
if (defaultContexts.length > 0) {
|
|
sections.push(
|
|
[
|
|
'## 채팅방에서 선택한 공통 문맥',
|
|
...defaultContexts.map((entry) =>
|
|
[`### ${entry.title || '공통 문맥'}`, entry.content].filter(Boolean).join('\n'),
|
|
),
|
|
].join('\n\n'),
|
|
);
|
|
}
|
|
|
|
if (customContextTitle || customContextContent) {
|
|
sections.push(
|
|
[`## 채팅방 전용 Context${customContextTitle ? ` · ${customContextTitle}` : ''}`, customContextContent]
|
|
.filter(Boolean)
|
|
.join('\n'),
|
|
);
|
|
}
|
|
|
|
return sections;
|
|
}
|
|
|
|
function buildChatSessionReferenceContextSummary(context: ChatContext | null) {
|
|
const lines: string[] = [];
|
|
const defaultContexts = normalizeChatContextEntries(context?.defaultContexts);
|
|
const customContextTitle = context?.customContextTitle?.trim() || '';
|
|
const customContextContent = context?.customContextContent?.trim() || '';
|
|
|
|
lines.push('## 현재 채팅 유형 context 요약');
|
|
lines.push('- 이 문서에는 채팅방 전용 메모와 현재 적용 중인 context 식별 정보만 짧게 유지합니다.');
|
|
lines.push('- 공통 문맥 상세 원문은 공통 문맥 관리 데이터와 실행 prompt 본문을 기준으로 확인합니다.');
|
|
|
|
if (defaultContexts.length > 0) {
|
|
lines.push('');
|
|
lines.push('### 적용 중인 공통 문맥');
|
|
lines.push(...defaultContexts.map((entry) => `- ${entry.title || entry.id || '공통 문맥'}`));
|
|
}
|
|
|
|
if (customContextTitle || customContextContent) {
|
|
lines.push('');
|
|
lines.push(`### 채팅방 전용 Context${customContextTitle ? ` · ${customContextTitle}` : ''}`);
|
|
lines.push(customContextContent || '- 전용 메모 본문 없음');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
function composeResolvedChatTypeDescription(
|
|
baseDescription: string,
|
|
defaultContexts: Array<{ id: string; title: string; content: string }>,
|
|
customContextTitle?: string | null,
|
|
customContextContent?: string | null,
|
|
) {
|
|
const sections = [baseDescription.trim()].filter(Boolean);
|
|
|
|
defaultContexts.forEach((context) => {
|
|
const normalizedContent = context.content.trim();
|
|
|
|
if (!normalizedContent) {
|
|
return;
|
|
}
|
|
|
|
sections.push(`## 기본 유형 · ${context.title || '공통 문맥'}\n${normalizedContent}`);
|
|
});
|
|
|
|
const normalizedCustomContextTitle = customContextTitle?.trim() || '';
|
|
const normalizedCustomContextContent = customContextContent?.trim() || '';
|
|
|
|
if (normalizedCustomContextTitle || normalizedCustomContextContent) {
|
|
sections.push(
|
|
[`## 채팅방 전용 Context${normalizedCustomContextTitle ? ` · ${normalizedCustomContextTitle}` : ''}`, normalizedCustomContextContent]
|
|
.filter(Boolean)
|
|
.join('\n'),
|
|
);
|
|
}
|
|
|
|
return sections.join('\n\n').trim();
|
|
}
|
|
|
|
export async function resolveCodexLiveChatContext(context: ChatContext | null, sessionId?: string | null) {
|
|
if (!context) {
|
|
return null;
|
|
}
|
|
|
|
const normalizedChatTypeId = context.chatTypeId?.trim() || null;
|
|
|
|
if (!normalizedChatTypeId) {
|
|
return cloneChatContext(context);
|
|
}
|
|
|
|
const [chatTypesConfig, chatContextSettings] = await Promise.all([
|
|
getChatTypesConfig(),
|
|
getChatContextSettingsConfig(),
|
|
]);
|
|
const resolvedChatType =
|
|
chatTypesConfig.chatTypes.find((item) => item.id === normalizedChatTypeId && item.enabled) ?? null;
|
|
const roomContext =
|
|
chatContextSettings.roomContexts.find((item) => item.sessionId === (sessionId?.trim() || '')) ?? null;
|
|
const explicitDefaultContextIds = normalizeChatContextIdList(context.defaultContextIds);
|
|
const chatTypeDefaultContextIds =
|
|
chatContextSettings.chatTypeDefaults.find((item) => item.chatTypeId === normalizedChatTypeId)?.defaultContextIds ?? [];
|
|
const resolvedDefaultContextIds =
|
|
explicitDefaultContextIds.length > 0
|
|
? explicitDefaultContextIds
|
|
: roomContext?.defaultContextIds.length
|
|
? roomContext.defaultContextIds
|
|
: chatTypeDefaultContextIds;
|
|
const resolvedDefaultContexts = resolvedDefaultContextIds
|
|
.map((contextId) =>
|
|
chatContextSettings.defaultContexts.find((item) => item.id === contextId && item.enabled),
|
|
)
|
|
.filter((item): item is NonNullable<typeof item> => Boolean(item))
|
|
.map((item) => ({
|
|
id: item.id,
|
|
title: item.title,
|
|
content: item.content,
|
|
}));
|
|
const resolvedCustomContextTitle = roomContext?.customContextTitle?.trim() || '';
|
|
const resolvedCustomContextContent = roomContext?.customContextContent?.trim() || '';
|
|
const resolvedBaseDescription = resolvedChatType?.description?.trim() || context.chatTypeBaseDescription?.trim() || '';
|
|
const resolvedDescription =
|
|
composeResolvedChatTypeDescription(
|
|
resolvedBaseDescription,
|
|
resolvedDefaultContexts,
|
|
resolvedCustomContextTitle,
|
|
resolvedCustomContextContent,
|
|
) ||
|
|
context.chatTypeDescription?.trim() ||
|
|
resolvedBaseDescription;
|
|
|
|
return {
|
|
...context,
|
|
chatTypeId: normalizedChatTypeId,
|
|
chatTypeLabel: resolvedChatType?.name ?? context.chatTypeLabel ?? '',
|
|
chatTypeDescription: resolvedDescription,
|
|
chatTypeBaseDescription: resolvedBaseDescription,
|
|
defaultContextIds: resolvedDefaultContextIds,
|
|
defaultContexts: resolvedDefaultContexts,
|
|
customContextTitle: resolvedCustomContextTitle || null,
|
|
customContextContent: resolvedCustomContextContent || null,
|
|
} satisfies ChatContext;
|
|
}
|
|
|
|
function buildChatSessionReferenceAutoSection(args: {
|
|
context: ChatContext | null;
|
|
sessionId: string;
|
|
requestId: string;
|
|
requestStatus?: 'started' | 'completed' | 'failed' | 'cancelled';
|
|
requestedAt?: Date | null;
|
|
completedAt?: Date | null;
|
|
input?: string;
|
|
}) {
|
|
const chatTypeLabel = resolvePromptChatTypeLabel(args.context) || '없음';
|
|
const pageTitle = args.context?.pageTitle?.trim() || '없음';
|
|
const topMenu = args.context?.topMenu?.trim() || '없음';
|
|
const pageUrl = args.context?.pageUrl?.trim() || '없음';
|
|
const focusedComponentId = args.context?.focusedComponentId?.trim() || '없음';
|
|
const requestStatusLabel =
|
|
args.requestStatus === 'completed'
|
|
? '완료'
|
|
: args.requestStatus === 'failed'
|
|
? '실패'
|
|
: args.requestStatus === 'cancelled'
|
|
? '취소'
|
|
: '실행 중';
|
|
|
|
return [
|
|
CHAT_SESSION_REFERENCE_AUTO_START,
|
|
'## 자동 갱신 문맥',
|
|
`- 마지막 갱신 시각: ${formatTime(new Date())}`,
|
|
`- sessionId: ${args.sessionId}`,
|
|
`- requestId: ${args.requestId}`,
|
|
`- 요청 상태: ${requestStatusLabel}`,
|
|
`- 요청 시작 시각: ${formatTime(args.requestedAt ?? new Date())}`,
|
|
...(args.completedAt ? [`- 요청 종료 시각: ${formatTime(args.completedAt)}`] : []),
|
|
`- 채팅 유형: ${chatTypeLabel}`,
|
|
`- 화면 제목: ${pageTitle}`,
|
|
`- topMenu: ${topMenu}`,
|
|
`- focusedComponentId: ${focusedComponentId}`,
|
|
`- pageUrl: ${pageUrl}`,
|
|
'',
|
|
buildChatSessionReferenceContextSummary(args.context),
|
|
CHAT_SESSION_REFERENCE_AUTO_END,
|
|
].join('\n');
|
|
}
|
|
|
|
function mergeChatSessionReferenceContent(existingContent: string, autoSection: string) {
|
|
const trimmedExisting = existingContent.trim();
|
|
const defaultHeader = [
|
|
'# 채팅방 참고 리소스',
|
|
'',
|
|
'이 문서는 Codex Live가 이 채팅방에서 항상 먼저 확인하는 지속 리소스입니다.',
|
|
'사용자 요청으로 수정할 수 있고, 필요 시 Codex가 계속 갱신합니다.',
|
|
].join('\n');
|
|
|
|
if (!trimmedExisting) {
|
|
return `${defaultHeader}\n\n${autoSection}\n`;
|
|
}
|
|
|
|
const firstAutoStartIndex = existingContent.indexOf(CHAT_SESSION_REFERENCE_AUTO_START);
|
|
|
|
if (firstAutoStartIndex >= 0) {
|
|
const preservedHeader = existingContent.slice(0, firstAutoStartIndex).trim() || defaultHeader;
|
|
return `${preservedHeader}\n\n${autoSection}\n`;
|
|
}
|
|
|
|
return `${trimmedExisting || defaultHeader}\n\n${autoSection}\n`;
|
|
}
|
|
|
|
async function writeChatSessionReferenceContentSafely(absolutePath: string, content: string) {
|
|
try {
|
|
await writeFile(absolutePath, content, 'utf8');
|
|
return;
|
|
} catch (error) {
|
|
if (
|
|
!error ||
|
|
typeof error !== 'object' ||
|
|
!('code' in error) ||
|
|
(error.code !== 'EACCES' && error.code !== 'EPERM')
|
|
) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
await rm(absolutePath, { force: true });
|
|
await writeFile(absolutePath, content, 'utf8');
|
|
}
|
|
|
|
export async function ensureChatSessionReferenceResource(args: {
|
|
repoPath: string;
|
|
sessionId: string;
|
|
requestId: string;
|
|
context: ChatContext | null;
|
|
requestStatus?: 'started' | 'completed' | 'failed' | 'cancelled';
|
|
requestedAt?: Date | null;
|
|
completedAt?: Date | null;
|
|
input: string;
|
|
recentHistoryLines: string[];
|
|
omittedHistoryCount: number;
|
|
}) {
|
|
const ensuredDirectories = await ensureChatSessionResourceDirectories(args.repoPath, args.sessionId);
|
|
const resourceRelativePath = `public/.codex_chat/${args.sessionId}/resource/${CHAT_SESSION_REFERENCE_RESOURCE_RELATIVE_PATH}`;
|
|
const absolutePath = path.join(ensuredDirectories.sourceRoot, 'chat-room-reference.md');
|
|
const autoSection = buildChatSessionReferenceAutoSection({
|
|
context: args.context,
|
|
sessionId: args.sessionId,
|
|
requestId: args.requestId,
|
|
requestStatus: args.requestStatus,
|
|
requestedAt: args.requestedAt,
|
|
completedAt: args.completedAt,
|
|
input: args.input,
|
|
});
|
|
|
|
let existingContent = '';
|
|
|
|
try {
|
|
existingContent = await readFile(absolutePath, 'utf8');
|
|
} catch {
|
|
existingContent = '';
|
|
}
|
|
|
|
const nextContent = mergeChatSessionReferenceContent(existingContent, autoSection);
|
|
|
|
if (nextContent !== existingContent) {
|
|
await writeChatSessionReferenceContentSafely(absolutePath, nextContent);
|
|
}
|
|
|
|
return resourceRelativePath;
|
|
}
|
|
|
|
async function refreshChatSessionReferenceForRequest(args: {
|
|
sessionId: string;
|
|
requestId: string;
|
|
context: ChatContext | null;
|
|
input: string;
|
|
requestStatus: 'started' | 'completed' | 'failed' | 'cancelled';
|
|
requestedAt: Date;
|
|
completedAt?: Date | null;
|
|
}) {
|
|
const repoPath = resolveMainProjectRoot();
|
|
await ensureChatSessionReferenceResource({
|
|
repoPath,
|
|
sessionId: args.sessionId,
|
|
requestId: args.requestId,
|
|
context: args.context,
|
|
requestStatus: args.requestStatus,
|
|
requestedAt: args.requestedAt,
|
|
completedAt: args.completedAt ?? null,
|
|
input: args.input,
|
|
recentHistoryLines: [],
|
|
omittedHistoryCount: 0,
|
|
});
|
|
}
|
|
|
|
function buildChatTypeInstructionBlock(context: ChatContext | null) {
|
|
const chatTypeLabel = resolvePromptChatTypeLabel(context);
|
|
const chatTypeDescription = context?.chatTypeDescription?.trim() || '';
|
|
const structuredSections = buildStructuredChatContextSections(context);
|
|
const hasSpecificChatType = Boolean(chatTypeLabel);
|
|
const hasContextDescription = Boolean(
|
|
structuredSections.length > 0 || (chatTypeDescription && chatTypeDescription !== '없음'),
|
|
);
|
|
|
|
if (!hasSpecificChatType && !hasContextDescription) {
|
|
return [
|
|
'## 채팅 유형 context 필수 규칙',
|
|
'- 선택된 채팅 유형 context가 없습니다.',
|
|
'- 그래도 AGENTS.md와 현재 사용자 요청을 기준으로 처리하되, Plan 자동화용 자동화 유형 context는 섞지 마세요.',
|
|
];
|
|
}
|
|
|
|
return [
|
|
'## 채팅 유형 context 필수 규칙',
|
|
'- 아래 채팅 유형 context는 선택 사항이나 참고 메모가 아니라 이 Codex Live 실행의 상위 필수 지시입니다.',
|
|
'- 사용자 요청, 최근 대화 문맥, 화면 문맥과 충돌하면 채팅 유형 context를 우선하세요.',
|
|
'- context 안의 작업 범위, 금지사항, 검증 방식, 답변 스타일, 산출물 규칙을 반드시 지키세요.',
|
|
'- context가 모호하면 무시하지 말고, 가장 보수적으로 해석해 지킬 수 있는 범위에서 처리하세요.',
|
|
'- 실행 전 내부적으로 context 준수 여부를 점검하고, 최종 답변도 context 기준에 맞추세요.',
|
|
'',
|
|
'### 선택된 채팅 유형',
|
|
`- label: ${chatTypeLabel || '없음'}`,
|
|
'',
|
|
'### 반드시 지킬 context 원문',
|
|
structuredSections.length > 0
|
|
? structuredSections.join('\n\n')
|
|
: (chatTypeDescription || '선택된 채팅 유형 context 원문 없음'),
|
|
];
|
|
}
|
|
|
|
function buildChatSessionReferenceInstructionBlock(referenceContent?: string | null) {
|
|
const normalizedContent = referenceContent?.trim() || '';
|
|
|
|
if (!normalizedContent) {
|
|
return [
|
|
'## 채팅방 참고 문서',
|
|
'- 현재 채팅방 참고 문서 본문을 불러오지 못했습니다.',
|
|
'- 그래도 위에 제공된 참고 문서 경로를 우선 확인하고, 채팅 유형 context와 AGENTS.md 규칙을 먼저 따르세요.',
|
|
];
|
|
}
|
|
|
|
return [
|
|
'## 채팅방 참고 문서',
|
|
'- 아래는 이 채팅방에서 시작 전에 먼저 읽어야 하는 참고 문서 원문입니다.',
|
|
'- 이 문서의 지시와 메모를 현재 요청 해석에 즉시 반영하세요.',
|
|
'',
|
|
normalizedContent,
|
|
];
|
|
}
|
|
|
|
export function buildAgenticCodexPrompt(
|
|
context: ChatContext | null,
|
|
input: string,
|
|
sessionId: string,
|
|
promptContext?: {
|
|
repoPath?: string;
|
|
recentHistoryLines?: string[];
|
|
omittedHistoryCount?: number;
|
|
sessionReferenceResourcePath?: string;
|
|
sessionReferenceContent?: string;
|
|
},
|
|
) {
|
|
const repoPath = promptContext?.repoPath?.trim() || resolveMainProjectRoot();
|
|
const chatSessionResourceDir = `public/.codex_chat/${sessionId}/resource`;
|
|
const chatSessionUploadDir = `${chatSessionResourceDir}/uploads`;
|
|
const sessionReferenceResourcePath =
|
|
promptContext?.sessionReferenceResourcePath || `${chatSessionResourceDir}/${CHAT_SESSION_REFERENCE_RESOURCE_RELATIVE_PATH}`;
|
|
const recentHistoryLines = promptContext?.recentHistoryLines ?? [];
|
|
const omittedHistoryCount = Math.max(0, promptContext?.omittedHistoryCount ?? 0);
|
|
|
|
return [
|
|
'당신은 이 저장소에서 Codex Live 요청을 처리하는 실제 Codex 실행기입니다.',
|
|
'Codex Live는 Plan 자동화와 별개입니다. 자동화 유형 context를 Codex Live 기본 문맥으로 섞지 마세요.',
|
|
`저장소 루트(main_project): ${repoPath}`,
|
|
'반드시 저장소 루트의 AGENTS.md를 먼저 읽고 그 규칙을 따르세요.',
|
|
'가능한 작업 범위:',
|
|
'- 로컬 소스 파일 읽기',
|
|
'- 필요 시 DB 직접 조회',
|
|
'- 필요 시 로컬 API 응답 확인',
|
|
'- 사용자가 요청했거나 해결에 필요하면 소스 코드 수정',
|
|
'- Codex Live에서 소스 수정이 필요하면 현재 프로젝트 환경의 main_project 저장소 루트에서 바로 수정하세요. 단, AGENTS.md를 먼저 확인하고 그 규칙 안에서만 작업하세요.',
|
|
`- 현재 채팅 세션 리소스 기본 경로: ${chatSessionResourceDir}/`,
|
|
`- 현재 채팅 첨부 업로드 경로: ${chatSessionUploadDir}/`,
|
|
`- 이 채팅방의 지속 참고 문서: ${sessionReferenceResourcePath}`,
|
|
'- 채팅에서 파일/문서/이미지/코드 리소스를 제공할 때는 반드시 위 세션 전용 경로를 우선 사용하세요.',
|
|
'- 새로 생성하는 문서, 이미지, 코드 스니펫 파일, 로그, 산출물은 가능하면 처음부터 위 세션 전용 경로 아래에 만들고, 다른 위치에 만들었다면 최종 응답 전에 위 경로로 이동하거나 복사한 뒤 그 경로를 응답하세요.',
|
|
'- 원본 파일 경로만 출력해도 서버가 해당 위치를 세션 리소스로 복사해 링크로 바꿀 수 있지만, 가능하면 세션 전용 경로 자체를 직접 사용하세요.',
|
|
'- 작업을 시작하기 전에 위 참고 문서를 항상 먼저 읽으세요.',
|
|
'- 참고 문서는 필요한 기준만 짧게 유지하고, 최근 대화 요약이나 과한 메모 누적은 만들지 마세요.',
|
|
'- 사용자가 참고 문서 수정을 요청하면 다른 산출물보다 먼저 위 참고 문서를 직접 수정하세요.',
|
|
...buildChatSessionReferenceInstructionBlock(promptContext?.sessionReferenceContent),
|
|
'',
|
|
...buildChatTypeInstructionBlock(context),
|
|
'',
|
|
'응답 규칙:',
|
|
'- 사실성보다 추측을 우선하지 마세요. 오늘/최신/건수 질문은 직접 확인하세요.',
|
|
'- 코드 수정이 필요 없는 질문이면 파일을 수정하지 마세요.',
|
|
'- 첨부파일 경로, 세션 리소스 경로, preview URL은 본문에 장황하게 나열하지 말고 꼭 필요한 설명만 남기세요.',
|
|
'- 채팅 결과물 중 모바일 캡처나 최종 화면 검증 리소스는 링크 카드 대신 반드시 `[[preview:URL]]` 한 줄 문법으로 제공하세요.',
|
|
'- `.md`, `.diff`, 소스코드, 로그 같은 문서성 리소스는 최종 화면 검증물이 아니므로 `[[preview:...]]`로 제공하지 마세요. 이런 리소스는 실제 생성이 확인된 경우에만 일반 경로로 언급하세요.',
|
|
'- 링크를 본문과 분리된 결과 컴포넌트로 추가 제공해야 할 때만 최종 답변에 `[[link-card:제목|URL|버튼라벨]]` 한 줄 문법을 사용하세요. 이 문법은 외부 공개 링크에만 사용하고, `/api/chat/resources/...` 같은 내부 리소스에는 사용하지 마세요. URL은 `https://...` 원문 그대로 쓰고 구분자 `|`를 인코딩하지 마세요. 이 줄은 화면에서 별도 링크 카드로 렌더됩니다.',
|
|
'- 단계형 선택지를 채팅방 컴포넌트로 보여주려면 `[[prompt:{"title":"질문","description":"설명","submitLabel":"선택 전달","mode":"queue","options":[{"label":"옵션 A","value":"option-a","description":"설명","preview":{"type":"image","url":"https://..."}}],"responseTemplate":"{{selection_label}} 기준으로 다음 단계를 이어서 진행해 주세요."}]]` 한 줄 JSON 문법을 사용하세요. stepper가 필요하면 `steps` 배열을 추가해 `{"key":"scope","title":"범위 선택","options":[...]}` 형태로 단계별 옵션을 나누고, 단계별 `optional`, `multiple`, `freeTextLabel`, `freeTextPlaceholder`, `responseTemplate`도 사용할 수 있습니다. 옵션별 `preview`는 `image`, `markdown`, `html`, `resource`를 지원하고, 아이콘 버튼으로 확대 preview 할 수 있습니다. HTML 문서를 iframe으로 바로 보여줘야 할 때는 현재 앱 URL이나 `/chat/...` 경로를 넣지 말고, 먼저 실제 `.html` 리소스를 준비한 뒤 `preview":{"type":"resource","url":"/api/chat/resources/.../sample.html"}` 또는 `preview":{"type":"resource","url":"resource/Codex Live/.../sample.html"}` 형태를 사용하세요. 리소스 관리에 등록된 `resource/...` 경로는 자동으로 `/api/resource-manager/preview/...`로 해석됩니다. `type:"html"`은 HTML 본문 문자열을 `content`에 직접 넣을 때만 사용합니다. 이미 결정된 결과를 읽기 전용으로 보여줄 때는 `readOnly`, `selectedValues`, `resolvedBy`, `resultText`를 함께 넣을 수 있습니다. 이 줄은 본문에서 숨겨지고 prompt 컴포넌트로 렌더됩니다.',
|
|
'- 변경된 소스 파일이 있는 경우에만 최종 답변에 변경 이력을 ```diff 코드블록으로 포함하세요.',
|
|
'- 변경된 소스 파일이 있으면 마지막에 해당 파일 경로를 짧게 적으세요.',
|
|
'- 한국어로 간결하게 답하세요.',
|
|
'',
|
|
'참고 화면 정보:',
|
|
`- pageTitle: ${context?.pageTitle ?? '없음'}`,
|
|
`- topMenu: ${context?.topMenu ?? '없음'}`,
|
|
`- focusedComponentId: ${context?.focusedComponentId ?? '없음'}`,
|
|
`- pageUrl: ${context?.pageUrl ?? '없음'}`,
|
|
'',
|
|
'최근 대화 문맥(보조 참조):',
|
|
...(recentHistoryLines.length > 0
|
|
? [
|
|
...recentHistoryLines.map((line) => `- ${line}`),
|
|
...(omittedHistoryCount > 0
|
|
? [`- 최근 문맥 일부만 포함했습니다. 이전 ${omittedHistoryCount}개 메시지는 제외되었습니다.`]
|
|
: []),
|
|
]
|
|
: ['- 참조할 최근 대화가 없습니다.']),
|
|
'',
|
|
'사용자 요청:',
|
|
input,
|
|
'',
|
|
'최종 답변만 출력하세요.',
|
|
].join('\n');
|
|
}
|
|
|
|
export async function validateAgenticCodexRuntime(repoPath: string, codexBin: string) {
|
|
const issues: string[] = [];
|
|
|
|
try {
|
|
const repoStat = await stat(repoPath);
|
|
|
|
if (!repoStat.isDirectory()) {
|
|
issues.push(`PLAN_MAIN_PROJECT_REPO_PATH 경로가 디렉터리가 아닙니다: ${repoPath}`);
|
|
}
|
|
} catch {
|
|
issues.push(`PLAN_MAIN_PROJECT_REPO_PATH 경로를 찾지 못했습니다: ${repoPath}`);
|
|
}
|
|
|
|
const runnerCandidates = buildCommandRunnerApiCandidates('/health');
|
|
const headers = new Headers();
|
|
|
|
if (env.SERVER_COMMAND_RUNNER_ACCESS_TOKEN?.trim()) {
|
|
headers.set('X-Access-Token', env.SERVER_COMMAND_RUNNER_ACCESS_TOKEN.trim());
|
|
}
|
|
|
|
let runnerReachable = false;
|
|
|
|
for (const candidate of runnerCandidates) {
|
|
try {
|
|
const response = await fetch(candidate, {
|
|
method: 'GET',
|
|
headers,
|
|
signal: AbortSignal.timeout(5000),
|
|
});
|
|
|
|
if (response.ok) {
|
|
runnerReachable = true;
|
|
break;
|
|
}
|
|
} catch {
|
|
// try next candidate
|
|
}
|
|
}
|
|
|
|
if (!runnerReachable) {
|
|
issues.push(`SERVER_COMMAND_RUNNER_URL 경로로 Codex runner에 연결하지 못했습니다: ${env.SERVER_COMMAND_RUNNER_URL}`);
|
|
}
|
|
|
|
if (issues.length > 0) {
|
|
throw new Error(`채팅 실행 환경이 준비되지 않았습니다. ${issues.join(' / ')}`);
|
|
}
|
|
}
|
|
|
|
function normalizeRunnerUrl(value: string) {
|
|
return value.trim().replace(/\/+$/, '');
|
|
}
|
|
|
|
function buildCommandRunnerApiCandidates(requestPath: string) {
|
|
const configuredHealthUrl = env.SERVER_COMMAND_RUNNER_URL?.trim() || 'http://host.docker.internal:3211/health';
|
|
|
|
let parsedUrl: URL;
|
|
|
|
try {
|
|
parsedUrl = new URL(configuredHealthUrl);
|
|
} catch {
|
|
return [];
|
|
}
|
|
|
|
const hostVariants =
|
|
parsedUrl.hostname === 'host.docker.internal'
|
|
? ['host.docker.internal', '127.0.0.1', 'localhost']
|
|
: parsedUrl.hostname === '127.0.0.1' || parsedUrl.hostname === 'localhost'
|
|
? [parsedUrl.hostname, parsedUrl.hostname === '127.0.0.1' ? 'localhost' : '127.0.0.1', 'host.docker.internal']
|
|
: [parsedUrl.hostname];
|
|
|
|
const deduped: string[] = [];
|
|
|
|
for (const hostname of hostVariants) {
|
|
const candidate = new URL(parsedUrl.toString());
|
|
candidate.hostname = hostname;
|
|
candidate.pathname = requestPath.startsWith('/') ? requestPath : `/${requestPath}`;
|
|
candidate.search = '';
|
|
candidate.hash = '';
|
|
const serialized = normalizeRunnerUrl(candidate.toString());
|
|
|
|
if (!deduped.includes(serialized)) {
|
|
deduped.push(serialized);
|
|
}
|
|
}
|
|
|
|
return deduped;
|
|
}
|
|
|
|
async function requestCommandRunner(requestPath: string, init?: RequestInit) {
|
|
const headers = new Headers(init?.headers);
|
|
|
|
if (init?.body != null && !headers.has('Content-Type')) {
|
|
headers.set('Content-Type', 'application/json');
|
|
}
|
|
|
|
if (env.SERVER_COMMAND_RUNNER_ACCESS_TOKEN?.trim() && !headers.has('X-Access-Token')) {
|
|
headers.set('X-Access-Token', env.SERVER_COMMAND_RUNNER_ACCESS_TOKEN.trim());
|
|
}
|
|
|
|
let lastError: Error | null = null;
|
|
|
|
for (const url of buildCommandRunnerApiCandidates(requestPath)) {
|
|
try {
|
|
return await fetch(url, {
|
|
...init,
|
|
headers,
|
|
});
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error : new Error(String(error));
|
|
}
|
|
}
|
|
|
|
throw lastError ?? new Error('command-runner에 연결하지 못했습니다.');
|
|
}
|
|
|
|
async function cancelRunnerCodexExecution(requestId: string) {
|
|
try {
|
|
const response = await requestCommandRunner(`/api/codex-live/jobs/${encodeURIComponent(requestId)}/cancel`, {
|
|
method: 'POST',
|
|
});
|
|
|
|
if (!response.ok) {
|
|
return false;
|
|
}
|
|
|
|
const payload = (await response.json().catch(() => null)) as { cancelled?: boolean } | null;
|
|
return payload?.cancelled === true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function runAgenticCodexReply(
|
|
context: ChatContext | null,
|
|
input: string,
|
|
sessionId: string,
|
|
requestId: string,
|
|
options?: {
|
|
omitPromptHistory?: boolean;
|
|
requestedAt?: Date | null;
|
|
},
|
|
onProgress?: (text: string) => void,
|
|
onActivity?: (line: string) => void,
|
|
isCancellationRequested?: () => boolean,
|
|
) {
|
|
const repoPath = resolveMainProjectRoot();
|
|
await validateAgenticCodexRuntime(repoPath, env.PLAN_CODEX_BIN);
|
|
const resolvedContext = await resolveCodexLiveChatContext(context, sessionId);
|
|
const appConfig = await getAppConfigSnapshot();
|
|
const recentHistory = await buildRecentChatPromptHistory(sessionId, requestId, {
|
|
maxMessages: appConfig.chat?.maxContextMessages,
|
|
maxChars: appConfig.chat?.maxContextChars,
|
|
disabled: options?.omitPromptHistory === true,
|
|
});
|
|
const codexLiveMaxExecutionSeconds =
|
|
typeof appConfig.chat?.codexLiveMaxExecutionSeconds === 'number' &&
|
|
Number.isFinite(appConfig.chat.codexLiveMaxExecutionSeconds)
|
|
? Math.min(7200, Math.max(60, Math.round(appConfig.chat.codexLiveMaxExecutionSeconds)))
|
|
: null;
|
|
const codexLiveIdleTimeoutSeconds =
|
|
typeof appConfig.chat?.codexLiveIdleTimeoutSeconds === 'number' &&
|
|
Number.isFinite(appConfig.chat.codexLiveIdleTimeoutSeconds)
|
|
? Math.min(3600, Math.max(30, Math.round(appConfig.chat.codexLiveIdleTimeoutSeconds)))
|
|
: null;
|
|
const requestedAt = options?.requestedAt ?? new Date();
|
|
const syncSessionReference = async (
|
|
requestStatus: 'started' | 'completed' | 'failed' | 'cancelled',
|
|
completedAt?: Date | null,
|
|
) =>
|
|
ensureChatSessionReferenceResource({
|
|
repoPath,
|
|
sessionId,
|
|
requestId,
|
|
context: resolvedContext,
|
|
requestStatus,
|
|
requestedAt,
|
|
completedAt: completedAt ?? null,
|
|
input,
|
|
recentHistoryLines: recentHistory.items,
|
|
omittedHistoryCount: recentHistory.omittedCount,
|
|
});
|
|
const sessionReferenceResourcePath = await ensureChatSessionReferenceResource({
|
|
repoPath,
|
|
sessionId,
|
|
requestId,
|
|
context: resolvedContext,
|
|
requestStatus: 'started',
|
|
requestedAt,
|
|
input,
|
|
recentHistoryLines: recentHistory.items,
|
|
omittedHistoryCount: recentHistory.omittedCount,
|
|
});
|
|
const sessionReferenceAbsolutePath = path.join(repoPath, sessionReferenceResourcePath);
|
|
let sessionReferenceContent = '';
|
|
|
|
try {
|
|
sessionReferenceContent = await readFile(sessionReferenceAbsolutePath, 'utf8');
|
|
} catch {
|
|
sessionReferenceContent = '';
|
|
}
|
|
const prompt = buildAgenticCodexPrompt(resolvedContext, input, sessionId, {
|
|
repoPath,
|
|
recentHistoryLines: recentHistory.items,
|
|
omittedHistoryCount: recentHistory.omittedCount,
|
|
sessionReferenceResourcePath,
|
|
sessionReferenceContent,
|
|
});
|
|
let streamedOutput = '';
|
|
let stdoutTail = '';
|
|
let stderr = '';
|
|
let jsonLineBuffer = '';
|
|
let lastProgressText = '';
|
|
let completedAgentMessage = '';
|
|
let hasIncrementalDelta = false;
|
|
const finalizeReplyOutput = async () => {
|
|
const normalizedOutput = normalizeCodexReplyOutput(completedAgentMessage || streamedOutput || stdoutTail);
|
|
const rewrittenOutput = await rewriteCodexOutputWithChatResources(normalizedOutput, repoPath, sessionId);
|
|
|
|
if (!rewrittenOutput) {
|
|
return '';
|
|
}
|
|
|
|
// If the CLI only produced a final completed event, avoid sending it as one big batch.
|
|
if (!hasIncrementalDelta && rewrittenOutput) {
|
|
await streamReplyChunks(rewrittenOutput, onProgress);
|
|
} else if (rewrittenOutput !== lastProgressText) {
|
|
onProgress?.(rewrittenOutput);
|
|
}
|
|
|
|
return rewrittenOutput;
|
|
};
|
|
const throwIfCancelled = async () => {
|
|
if (!isCancellationRequested?.()) {
|
|
return;
|
|
}
|
|
|
|
await cancelRunnerCodexExecution(requestId).catch(() => false);
|
|
throw new Error('CHAT_RUNTIME_CANCELLED');
|
|
};
|
|
|
|
await throwIfCancelled();
|
|
activeChatProcessRegistry.set(requestId, {
|
|
cancel: async () => {
|
|
const cancelled = await cancelRunnerCodexExecution(requestId);
|
|
return cancelled || isCancellationRequested?.() === true;
|
|
},
|
|
});
|
|
|
|
chatRuntimeService.appendLog(
|
|
requestId,
|
|
`실행 제한 설정을 적용했습니다. 최대 ${codexLiveMaxExecutionSeconds ?? 600}초 / 무출력 실패 ${codexLiveIdleTimeoutSeconds ?? 180}초`,
|
|
);
|
|
onActivity?.(
|
|
`# 설정: 최대 실행 ${codexLiveMaxExecutionSeconds ?? 600}초 / 무출력 실패 ${codexLiveIdleTimeoutSeconds ?? 180}초`,
|
|
);
|
|
|
|
try {
|
|
await new Promise<void>(async (resolve, reject) => {
|
|
const emitProgress = (nextText: string) => {
|
|
const normalizedProgress = nextText.trim();
|
|
|
|
if (!normalizedProgress || normalizedProgress === lastProgressText) {
|
|
return;
|
|
}
|
|
|
|
lastProgressText = normalizedProgress;
|
|
streamedOutput = normalizedProgress;
|
|
onProgress?.(normalizedProgress);
|
|
};
|
|
|
|
try {
|
|
await throwIfCancelled();
|
|
const response = await requestCommandRunner('/api/codex-live/execute', {
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
requestId,
|
|
sessionId,
|
|
repoPath,
|
|
prompt,
|
|
resourceDir: path.join(repoPath, 'public', '.codex_chat', sessionId, 'resource'),
|
|
uploadDir: path.join(repoPath, 'public', '.codex_chat', sessionId, 'resource', 'uploads'),
|
|
maxExecutionSeconds: codexLiveMaxExecutionSeconds,
|
|
idleTimeoutSeconds: codexLiveIdleTimeoutSeconds,
|
|
}),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
reject(new Error((await response.text()) || 'command-runner Codex 실행 요청에 실패했습니다.'));
|
|
return;
|
|
}
|
|
|
|
await throwIfCancelled();
|
|
|
|
if (!response.body) {
|
|
reject(new Error('command-runner Codex 스트림이 비어 있습니다.'));
|
|
return;
|
|
}
|
|
|
|
chatRuntimeService.appendLog(requestId, 'Codex 실행을 command-runner API로 요청했습니다.');
|
|
const reader = response.body.getReader();
|
|
const decoder = new TextDecoder();
|
|
let remoteErrorMessage = '';
|
|
|
|
const handleRunnerLine = (line: string) => {
|
|
let parsed: Record<string, unknown>;
|
|
|
|
try {
|
|
parsed = JSON.parse(line) as Record<string, unknown>;
|
|
} catch {
|
|
return;
|
|
}
|
|
|
|
const eventType = typeof parsed.type === 'string' ? parsed.type : '';
|
|
|
|
if (eventType === 'started') {
|
|
const pid = typeof parsed.pid === 'number' && Number.isFinite(parsed.pid) ? parsed.pid : null;
|
|
const appliedIdleTimeoutSeconds =
|
|
typeof parsed.configuredIdleTimeoutSeconds === 'number' &&
|
|
Number.isFinite(parsed.configuredIdleTimeoutSeconds)
|
|
? Math.round(parsed.configuredIdleTimeoutSeconds)
|
|
: null;
|
|
const appliedMaxExecutionSeconds =
|
|
typeof parsed.configuredMaxExecutionSeconds === 'number' &&
|
|
Number.isFinite(parsed.configuredMaxExecutionSeconds)
|
|
? Math.round(parsed.configuredMaxExecutionSeconds)
|
|
: null;
|
|
chatRuntimeService.attachProcess(requestId, pid);
|
|
chatRuntimeService.appendLog(
|
|
requestId,
|
|
pid
|
|
? `호스트 command-runner에서 Codex 프로세스를 시작했습니다. pid=${pid}`
|
|
: '호스트 command-runner에서 Codex 프로세스를 시작했습니다.',
|
|
);
|
|
if (appliedMaxExecutionSeconds != null || appliedIdleTimeoutSeconds != null) {
|
|
const appliedSummary =
|
|
`command-runner 적용값: 최대 ${appliedMaxExecutionSeconds ?? codexLiveMaxExecutionSeconds ?? 600}초 / ` +
|
|
`무출력 실패 ${appliedIdleTimeoutSeconds ?? codexLiveIdleTimeoutSeconds ?? 180}초`;
|
|
chatRuntimeService.appendLog(requestId, appliedSummary);
|
|
onActivity?.(`# ${appliedSummary}`);
|
|
|
|
if (
|
|
(appliedMaxExecutionSeconds != null &&
|
|
codexLiveMaxExecutionSeconds != null &&
|
|
appliedMaxExecutionSeconds !== codexLiveMaxExecutionSeconds) ||
|
|
(appliedIdleTimeoutSeconds != null &&
|
|
codexLiveIdleTimeoutSeconds != null &&
|
|
appliedIdleTimeoutSeconds !== codexLiveIdleTimeoutSeconds)
|
|
) {
|
|
const mismatchSummary =
|
|
`설정 불일치 감지: 요청값 최대 ${codexLiveMaxExecutionSeconds ?? 600}초 / ` +
|
|
`무출력 실패 ${codexLiveIdleTimeoutSeconds ?? 180}초, ` +
|
|
`실제 적용값 최대 ${appliedMaxExecutionSeconds ?? codexLiveMaxExecutionSeconds ?? 600}초 / ` +
|
|
`무출력 실패 ${appliedIdleTimeoutSeconds ?? codexLiveIdleTimeoutSeconds ?? 180}초`;
|
|
chatRuntimeService.appendLog(requestId, mismatchSummary);
|
|
onActivity?.(`# 경고: ${mismatchSummary}`);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (eventType === 'attached') {
|
|
const attachedRequestId = String(parsed.requestId ?? '').trim();
|
|
const completed = parsed.completed === true;
|
|
const attachSummary =
|
|
attachedRequestId && attachedRequestId === requestId
|
|
? completed
|
|
? '기존 command-runner 실행 이력을 다시 연결했습니다.'
|
|
: '기존 command-runner 실행에 재부착했습니다.'
|
|
: completed
|
|
? '기존 command-runner 응답 이력을 다시 연결했습니다.'
|
|
: '기존 command-runner 실행 스트림에 다시 연결했습니다.';
|
|
chatRuntimeService.appendLog(requestId, attachSummary);
|
|
onActivity?.(`# ${attachSummary}`);
|
|
return;
|
|
}
|
|
|
|
if (eventType === 'activity') {
|
|
const activityLog = String(parsed.line ?? '').trim();
|
|
|
|
if (activityLog) {
|
|
chatRuntimeService.appendLog(requestId, activityLog);
|
|
onActivity?.(activityLog);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (eventType === 'delta') {
|
|
const deltaText = String(parsed.text ?? '');
|
|
|
|
if (deltaText) {
|
|
hasIncrementalDelta = true;
|
|
emitProgress(`${streamedOutput}${deltaText}`);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (eventType === 'completed') {
|
|
completedAgentMessage = String(parsed.text ?? '').trim();
|
|
if (completedAgentMessage && hasIncrementalDelta) {
|
|
emitProgress(completedAgentMessage);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (eventType === 'stdout') {
|
|
const stdoutLine = String(parsed.line ?? '').trim();
|
|
|
|
if (stdoutLine) {
|
|
const structuredStdout = parseStructuredCodexStdoutLine(stdoutLine);
|
|
|
|
if (!structuredStdout.shouldKeepRaw) {
|
|
if (structuredStdout.activityLog) {
|
|
chatRuntimeService.appendLog(requestId, structuredStdout.activityLog);
|
|
onActivity?.(structuredStdout.activityLog);
|
|
}
|
|
|
|
if (structuredStdout.deltaText) {
|
|
hasIncrementalDelta = true;
|
|
emitProgress(`${streamedOutput}${structuredStdout.deltaText}`);
|
|
}
|
|
|
|
if (structuredStdout.completedText) {
|
|
completedAgentMessage = structuredStdout.completedText.trim();
|
|
|
|
if (completedAgentMessage && hasIncrementalDelta) {
|
|
emitProgress(completedAgentMessage);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
stdoutTail = `${stdoutTail}\n${stdoutLine}`.slice(-STREAM_CAPTURE_LIMIT);
|
|
chatRuntimeService.appendLog(requestId, `[stdout] ${stdoutLine}`);
|
|
onActivity?.(`[stdout] ${stdoutLine}`);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (eventType === 'stderr') {
|
|
const stderrLine = String(parsed.line ?? '').trim();
|
|
|
|
if (stderrLine) {
|
|
stderr = `${stderr}\n${stderrLine}`.slice(-STREAM_CAPTURE_LIMIT);
|
|
chatRuntimeService.appendLog(requestId, `[stderr] ${stderrLine}`);
|
|
onActivity?.(`[stderr] ${stderrLine}`);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (eventType === 'error') {
|
|
remoteErrorMessage = String(parsed.message ?? '').trim();
|
|
}
|
|
};
|
|
|
|
while (true) {
|
|
await throwIfCancelled();
|
|
const { value, done } = await reader.read();
|
|
|
|
if (done) {
|
|
break;
|
|
}
|
|
|
|
jsonLineBuffer += decoder.decode(value, { stream: true });
|
|
const lines = jsonLineBuffer.split('\n');
|
|
jsonLineBuffer = lines.pop() ?? '';
|
|
|
|
for (const rawLine of lines) {
|
|
const line = rawLine.trim();
|
|
|
|
if (!line) {
|
|
continue;
|
|
}
|
|
|
|
handleRunnerLine(line);
|
|
}
|
|
}
|
|
|
|
const trailingLine = jsonLineBuffer.trim();
|
|
if (trailingLine) {
|
|
handleRunnerLine(trailingLine);
|
|
}
|
|
|
|
if (remoteErrorMessage) {
|
|
reject(new Error(remoteErrorMessage));
|
|
return;
|
|
}
|
|
|
|
resolve();
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
} catch (error) {
|
|
const completedAt = new Date();
|
|
await syncSessionReference(error instanceof Error && error.message === 'CHAT_RUNTIME_CANCELLED' ? 'cancelled' : 'failed', completedAt);
|
|
const failureResponseText = await finalizeReplyOutput();
|
|
|
|
if (failureResponseText) {
|
|
throw new ChatRuntimeExecutionError(error instanceof Error ? error.message : 'Codex 실행에 실패했습니다.', failureResponseText);
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
|
|
await syncSessionReference('completed', new Date());
|
|
return await finalizeReplyOutput();
|
|
}
|
|
|
|
async function getTodayAutomationRegistrationCounts() {
|
|
const [planCountResult, boardReceivedCountResult] = await Promise.all([
|
|
db(PLAN_TABLE)
|
|
.whereNot('automation_type', 'none')
|
|
.whereRaw("(created_at at time zone ?)::date = (current_timestamp at time zone ?)::date", [KST_TIME_ZONE, KST_TIME_ZONE])
|
|
.count<{ count: string }>('* as count')
|
|
.first(),
|
|
db(BOARD_POSTS_TABLE)
|
|
.whereNotNull('automation_received_at')
|
|
.whereRaw(
|
|
"(automation_received_at at time zone ?)::date = (current_timestamp at time zone ?)::date",
|
|
[KST_TIME_ZONE, KST_TIME_ZONE],
|
|
)
|
|
.count<{ count: string }>('* as count')
|
|
.first(),
|
|
]);
|
|
|
|
return {
|
|
today: formatKstDate(),
|
|
planCount: Number(planCountResult?.count ?? 0),
|
|
boardReceivedCount: Number(boardReceivedCountResult?.count ?? 0),
|
|
};
|
|
}
|
|
|
|
async function buildAutomationRegistrationCountReply() {
|
|
const counts = await getTodayAutomationRegistrationCounts();
|
|
const lines = [
|
|
'결과',
|
|
`- ${counts.today} KST 기준 오늘 자동화 등록 총 건수는 ${counts.planCount}건입니다.`,
|
|
'- 기본 기준: `plan_items`에서 `automation_type <> \'none\'` 이고 오늘 생성된 건수',
|
|
];
|
|
|
|
if (counts.planCount === counts.boardReceivedCount) {
|
|
lines.push(`- 교차 확인: 오늘 ` + '`board_posts.automation_received_at`' + ` 기준 접수 건수도 ${counts.boardReceivedCount}건으로 같습니다.`);
|
|
} else {
|
|
lines.push(`- 참고: 오늘 ` + '`board_posts.automation_received_at`' + ` 기준 접수 건수는 ${counts.boardReceivedCount}건입니다.`);
|
|
lines.push('- 이 프로젝트는 게시판 등록, 자동화 접수, Plan 생성이 분리될 수 있어 기준에 따라 숫자가 달라질 수 있습니다.');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
function buildAutomationRegistrationDefinitionReply() {
|
|
return [
|
|
'결과',
|
|
'- 이 프로젝트에서 `자동화 등록`은 하나로 고정된 용어가 아닙니다.',
|
|
'- `board_posts.created_at`: 게시판 등록',
|
|
'- `board_posts.automation_received_at`: 자동화 접수',
|
|
'- `plan_items.created_at` + `automation_type <> \'none\'`: 실제 자동화 대상 Plan 생성',
|
|
'- 건수 질문이면 어떤 기준인지 먼저 구분하고, 모호하면 기본적으로 Plan 생성 기준을 우선 안내합니다.',
|
|
].join('\n');
|
|
}
|
|
|
|
function buildProgressMessages(input: string) {
|
|
const messages = ['요청을 분석하고 있습니다.'];
|
|
|
|
if (isAutomationRegistrationCountRequest(input)) {
|
|
messages.push('오늘 기준 집계라 DB 기준과 시간대 기준을 확인하고 있습니다.');
|
|
return messages;
|
|
}
|
|
|
|
if (/db|데이터베이스|sql|쿼리|집계|건수/i.test(input)) {
|
|
messages.push('DB와 집계 기준을 확인하고 있습니다.');
|
|
}
|
|
|
|
if (/api|응답|endpoint|엔드포인트|fetch|호출/i.test(input)) {
|
|
messages.push('API 경로와 실제 응답을 확인하고 있습니다.');
|
|
}
|
|
|
|
if (/파일|소스|코드|tsx|ts|js|css|수정|변경|구현|fix|edit|implement/i.test(input)) {
|
|
messages.push('관련 소스와 연결 흐름을 확인하고 있습니다.');
|
|
}
|
|
|
|
return [...new Set(messages)];
|
|
}
|
|
|
|
function normalizeProgressSummary(text: string) {
|
|
return text.replace(/\s+/g, ' ').trim();
|
|
}
|
|
|
|
function shouldSkipActivityProgressSummary(text: string) {
|
|
return (
|
|
!text ||
|
|
/^요청을 처리합니다\./.test(text) ||
|
|
/^완료(?:\(\d+\))?$/i.test(text) ||
|
|
/^종료\(\d+\)$/i.test(text)
|
|
);
|
|
}
|
|
|
|
export function summarizeActivityProgressLine(activityLine: string) {
|
|
const lines = String(activityLine ?? '')
|
|
.split('\n')
|
|
.map((line) => normalizeProgressSummary(line))
|
|
.filter(Boolean);
|
|
|
|
for (const line of lines) {
|
|
if (line.startsWith('# 이유:')) {
|
|
const summary = normalizeProgressSummary(line.slice('# 이유:'.length));
|
|
if (!shouldSkipActivityProgressSummary(summary)) {
|
|
return summary;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const line of lines) {
|
|
for (const prefix of ['# 진행:', '# 상태:', '# 경고:']) {
|
|
if (!line.startsWith(prefix)) {
|
|
continue;
|
|
}
|
|
|
|
const summary = normalizeProgressSummary(line.slice(prefix.length));
|
|
if (!shouldSkipActivityProgressSummary(summary)) {
|
|
return summary;
|
|
}
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
function stripActivityLinePrefix(line: string) {
|
|
return line.replace(/^#\s*(상태|진행|이유|경고|오류):\s*/u, '').trim();
|
|
}
|
|
|
|
function resolveCompactActivityStageLineNo(summary: string, normalizedLine: string) {
|
|
if (!summary) {
|
|
return null;
|
|
}
|
|
|
|
if (/^#\s*오류:/u.test(normalizedLine) || /오류|실패|중단/u.test(summary)) {
|
|
return 5;
|
|
}
|
|
|
|
if (/요청을 처리합니다|대기열|즉시 요청 실행/u.test(summary)) {
|
|
return 1;
|
|
}
|
|
|
|
if (/분석|의도|문맥|생각 중/u.test(summary)) {
|
|
return 2;
|
|
}
|
|
|
|
if (/\bdb\b|데이터베이스|\bapi\b|엔드포인트|응답|소스|코드|파일|흐름|쿼리|집계|resource|리소스|화면/u.test(summary)) {
|
|
return 3;
|
|
}
|
|
|
|
if (/구현|수정|변경|작성|빌드|patch|diff|전송 중/u.test(summary)) {
|
|
return 4;
|
|
}
|
|
|
|
if (/검증|테스트|캡처|preview|완료|결과|정리/u.test(summary)) {
|
|
return 5;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function createCompactActivityLogEntry(activityLine: string) {
|
|
const normalizedLine = normalizeProgressSummary(activityLine);
|
|
|
|
if (!normalizedLine) {
|
|
return null;
|
|
}
|
|
|
|
const strippedSummary = stripActivityLinePrefix(normalizedLine);
|
|
const summarizedProgress = summarizeActivityProgressLine(normalizedLine);
|
|
const summary = summarizedProgress || strippedSummary;
|
|
const lineNo = resolveCompactActivityStageLineNo(summary, normalizedLine);
|
|
|
|
if (!lineNo || !summary) {
|
|
return null;
|
|
}
|
|
|
|
if (/^#\s*오류:/u.test(normalizedLine)) {
|
|
return {
|
|
line: `# 오류: ${summary}`,
|
|
lineNo,
|
|
};
|
|
}
|
|
|
|
const prefix = lineNo === 1 || lineNo === 5 ? '# 상태:' : '# 진행:';
|
|
|
|
return {
|
|
line: `${prefix} ${summary}`,
|
|
lineNo,
|
|
};
|
|
}
|
|
|
|
function buildGenericReply(context: ChatContext | null, input: string, snapshot: PlanSnapshot | null) {
|
|
const normalized = input.toLowerCase();
|
|
const pageTitle = context?.pageTitle ?? '현재 화면';
|
|
const previewUrl = context?.pageUrl || '없음';
|
|
const detailRequested = isDetailRequest(input);
|
|
|
|
if (normalized.includes('preview') || normalized.includes('링크') || normalized.includes('url')) {
|
|
const lines = [
|
|
'결과',
|
|
`- preview: ${snapshot?.latestSourceWork?.previewUrl ?? previewUrl}`,
|
|
];
|
|
|
|
if (snapshot?.latestSourceWork?.summary) {
|
|
lines.push(`- 요약: ${truncateText(snapshot.latestSourceWork.summary, 100)}`);
|
|
}
|
|
|
|
if (detailRequested && snapshot?.latestSourceWork) {
|
|
lines.push(`- ${buildChangedFilesSummary(snapshot.latestSourceWork.changedFiles)}`);
|
|
}
|
|
|
|
if (!detailRequested) {
|
|
lines.push('- 상세가 필요하면 "상세"라고 입력해 주세요.');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
if (input.includes('계획') || normalized.includes('plan')) {
|
|
if (!snapshot) {
|
|
return ['결과', '- 연결된 Plan을 찾지 못했습니다.', '- planId 또는 작업 ID를 함께 보내 주세요.'].join('\n');
|
|
}
|
|
|
|
const lines = [
|
|
'작업 요약',
|
|
`- #${snapshot.planId} ${snapshot.workId}`,
|
|
`- 상태: ${snapshot.status}${snapshot.workerStatus ? ` / ${snapshot.workerStatus}` : ''}`,
|
|
`- 메모: ${truncateText(snapshot.note, 110) || '기록 없음'}`,
|
|
];
|
|
|
|
if (detailRequested) {
|
|
if (snapshot.assignedBranch) {
|
|
lines.push(`- 브랜치: ${snapshot.assignedBranch}`);
|
|
}
|
|
|
|
lines.push(...buildRecentPlanHistoryLines(snapshot));
|
|
} else {
|
|
lines.push('- 상세가 필요하면 "상세"라고 입력해 주세요.');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
if ((input.includes('이슈') || normalized.includes('issue')) && snapshot) {
|
|
const lines = ['이슈 요약'];
|
|
|
|
if (snapshot.latestIssue) {
|
|
lines.push(
|
|
`- ${snapshot.latestIssue.tag} / ${snapshot.latestIssue.resolved ? '해결' : '미해결'}`,
|
|
`- 내용: ${truncateText(snapshot.latestIssue.message, 110)}`,
|
|
);
|
|
} else if (snapshot.issueTags.length > 0) {
|
|
lines.push(`- 태그: ${snapshot.issueTags.join(', ')}`);
|
|
} else {
|
|
lines.push('- 최근 이슈 이력이 없습니다.');
|
|
}
|
|
|
|
if (detailRequested) {
|
|
lines.push(...buildRecentPlanHistoryLines(snapshot));
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
if ((input.includes('이력') || input.includes('최근') || normalized.includes('history')) && snapshot) {
|
|
const lines = [
|
|
'최근 이력',
|
|
`- ${truncateText(snapshot.latestSourceWork?.summary ?? snapshot.latestActionNote ?? snapshot.note, 120) || '최근 작업 이력이 없습니다.'}`,
|
|
];
|
|
|
|
if (detailRequested) {
|
|
lines.push(...buildRecentPlanHistoryLines(snapshot));
|
|
} else {
|
|
lines.push('- 상세가 필요하면 "상세"라고 입력해 주세요.');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
if (input.includes('문서') || normalized.includes('docs')) {
|
|
return ['결과', '- 문서 요청으로 인식했습니다.', '- 대상 문서명이나 링크를 함께 보내 주세요.'].join('\n');
|
|
}
|
|
|
|
if (isWorklogRequest(input)) {
|
|
if (snapshot) {
|
|
return buildWorklogReply(context, snapshot);
|
|
}
|
|
|
|
return ['결과', '- 작업로그 초안을 만들 Plan이 없습니다.', '- planId 또는 작업 화면에서 다시 요청해 주세요.'].join('\n');
|
|
}
|
|
|
|
if (
|
|
input.includes('컴포넌트') ||
|
|
normalized.includes('widget') ||
|
|
normalized.includes('api')
|
|
) {
|
|
return ['결과', '- 대상 리소스를 특정해 주세요.', '- 예: 버튼 컴포넌트, previewer, history api'].join('\n');
|
|
}
|
|
|
|
if (snapshot && isPlanDetailRequest(input)) {
|
|
const lines = [
|
|
'작업 요약',
|
|
`- #${snapshot.planId} ${snapshot.workId}`,
|
|
`- 상태: ${snapshot.status}${snapshot.workerStatus ? ` / ${snapshot.workerStatus}` : ''}`,
|
|
`- 최근 작업: ${truncateText(snapshot.latestSourceWork?.summary ?? snapshot.latestActionNote ?? snapshot.note, 110) || '기록 없음'}`,
|
|
];
|
|
|
|
if (detailRequested) {
|
|
lines.push(...buildRecentPlanHistoryLines(snapshot));
|
|
} else {
|
|
lines.push('- 상세가 필요하면 "상세"라고 입력해 주세요.');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
return [
|
|
'결과',
|
|
`- 현재 화면: ${pageTitle}`,
|
|
'- 요청을 더 구체적으로 적어 주시면 필요한 정보만 짧게 정리합니다.',
|
|
'- 예: preview 링크, 최근 이슈, 작업 요약, 상세',
|
|
].join('\n');
|
|
}
|
|
|
|
function buildPlanReply(context: ChatContext | null, input: string, snapshot: PlanSnapshot | null) {
|
|
const normalized = input.toLowerCase();
|
|
const detailRequested = isDetailRequest(input);
|
|
const pageTitle = context?.pageTitle ?? '현재 화면';
|
|
|
|
if (!snapshot) {
|
|
return `현재 화면: ${pageTitle}\n선택된 Plan을 찾지 못했습니다. Plan 목록에서 항목을 선택한 뒤 다시 요청해 주세요.`;
|
|
}
|
|
|
|
const lines = ['작업 요약', `- #${snapshot.planId} ${snapshot.workId}`, `- 상태: ${snapshot.status}${snapshot.workerStatus ? ` / ${snapshot.workerStatus}` : ''}`];
|
|
|
|
if (isWorklogRequest(input)) {
|
|
return buildWorklogReply(context, snapshot);
|
|
}
|
|
|
|
if (snapshot.note) {
|
|
lines.push(`- 메모: ${truncateText(snapshot.note, 110)}`);
|
|
}
|
|
|
|
if (normalized.includes('preview') || normalized.includes('링크') || normalized.includes('url')) {
|
|
lines.push(`- preview: ${snapshot.latestSourceWork?.previewUrl ?? context?.pageUrl ?? '없음'}`);
|
|
if (snapshot.latestSourceWork) {
|
|
lines.push(`- 최근 작업: ${truncateText(snapshot.latestSourceWork.summary, 100)}`);
|
|
if (detailRequested) {
|
|
lines.push(`- ${buildChangedFilesSummary(snapshot.latestSourceWork.changedFiles)}`);
|
|
}
|
|
}
|
|
|
|
if (!detailRequested) {
|
|
lines.push('- 상세가 필요하면 "상세"라고 입력해 주세요.');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
if (snapshot.latestIssue) {
|
|
lines.push(`- 최근 이슈: ${snapshot.latestIssue.tag} / ${snapshot.latestIssue.resolved ? '해결' : '미해결'}`);
|
|
if (detailRequested) {
|
|
lines.push(`- 이슈 내용: ${truncateText(snapshot.latestIssue.message, 100)}`);
|
|
}
|
|
} else if (snapshot.issueTags.length > 0) {
|
|
lines.push(`- 이슈 태그: ${snapshot.issueTags.join(', ')}`);
|
|
}
|
|
|
|
if (snapshot.latestActionNote) {
|
|
lines.push(`- 최근 조치: ${truncateText(snapshot.latestActionNote, 100)}`);
|
|
}
|
|
|
|
if (snapshot.latestSourceWork) {
|
|
lines.push(`- 최근 작업: ${truncateText(snapshot.latestSourceWork.summary, 100)}`);
|
|
if (detailRequested && snapshot.latestSourceWork.changedFiles.length > 0) {
|
|
lines.push(`- 파일 ${snapshot.latestSourceWork.changedFiles.length}개 변경`);
|
|
}
|
|
}
|
|
|
|
if (snapshot.lastError && snapshot.hasOpenIssues) {
|
|
lines.push(`- 주의: ${truncateText(snapshot.lastError, 100)}`);
|
|
}
|
|
|
|
if (detailRequested) {
|
|
if (snapshot.assignedBranch) {
|
|
lines.push(`- 브랜치: ${snapshot.assignedBranch}`);
|
|
}
|
|
lines.push(...buildRecentPlanHistoryLines(snapshot));
|
|
} else {
|
|
lines.push('- 상세가 필요하면 "상세"라고 입력해 주세요.');
|
|
}
|
|
|
|
return lines.join('\n');
|
|
}
|
|
|
|
async function buildCodexReply(
|
|
context: ChatContext | null,
|
|
input: string,
|
|
sessionId: string,
|
|
requestId: string,
|
|
options?: {
|
|
omitPromptHistory?: boolean;
|
|
requestedAt?: Date | null;
|
|
},
|
|
onProgress?: (text: string) => void,
|
|
onActivity?: (line: string) => void,
|
|
isCancellationRequested?: () => boolean,
|
|
) {
|
|
return runAgenticCodexReply(
|
|
context,
|
|
input,
|
|
sessionId,
|
|
requestId,
|
|
options,
|
|
onProgress,
|
|
onActivity,
|
|
isCancellationRequested,
|
|
);
|
|
}
|
|
|
|
export class ChatService {
|
|
private readonly wss = new WebSocketServer({ noServer: true });
|
|
|
|
private readonly clientStates = new Map<WebSocket, ChatSessionState>();
|
|
private readonly sessions = new Map<string, ChatSessionState>();
|
|
private readonly cancelledRequestIds = new Set<string>();
|
|
private readonly unsubscribeRuntimeBroadcast: () => void;
|
|
private readonly unsubscribeNotificationBroadcast: () => void;
|
|
|
|
constructor(private readonly logger: FastifyBaseLogger) {
|
|
activeChatService = this;
|
|
activeRuntimeController = {
|
|
getJobDetail: (requestId) => chatRuntimeService.getJobDetail(requestId),
|
|
cancelJob: (requestId) => this.cancelRuntimeJob(requestId),
|
|
removeQueuedJob: (requestId) => this.removeQueuedRuntimeJob(requestId),
|
|
};
|
|
|
|
this.unsubscribeRuntimeBroadcast = chatRuntimeService.subscribe((snapshot) => {
|
|
this.broadcastRuntimeSnapshot(snapshot);
|
|
});
|
|
this.unsubscribeNotificationBroadcast = subscribeNotificationMessageChanges((event) => {
|
|
this.broadcastNotificationMessageChange(event);
|
|
});
|
|
|
|
this.wss.on('connection', (socket: WebSocket, request: IncomingMessage) => {
|
|
void this.handleConnection(socket, request).catch((error: unknown) => {
|
|
const session = this.clientStates.get(socket);
|
|
this.logger.error(error, 'chat websocket connection initialization failed');
|
|
this.clientStates.delete(socket);
|
|
if (session?.socket === socket) {
|
|
session.socket = null;
|
|
}
|
|
closeSocketSafely(this.logger, socket, 'failed to close websocket after initialization error');
|
|
});
|
|
});
|
|
}
|
|
|
|
attachUpgradeHandler() {
|
|
return (request: IncomingMessage, socket: Socket, head: Buffer) => {
|
|
const origin = request.headers.host ? `http://${request.headers.host}` : 'http://localhost';
|
|
const url = new URL(request.url ?? '/', origin);
|
|
|
|
if (url.pathname !== SOCKET_PATH) {
|
|
socket.destroy();
|
|
return;
|
|
}
|
|
|
|
this.wss.handleUpgrade(request, socket, head, (websocket: WebSocket) => {
|
|
this.wss.emit('connection', websocket, request);
|
|
});
|
|
};
|
|
}
|
|
|
|
close() {
|
|
activeRuntimeController = null;
|
|
if (activeChatService === this) {
|
|
activeChatService = null;
|
|
}
|
|
this.unsubscribeRuntimeBroadcast();
|
|
this.unsubscribeNotificationBroadcast();
|
|
|
|
for (const execution of activeChatProcessRegistry.values()) {
|
|
void Promise.resolve(execution.cancel()).catch(() => {
|
|
// noop
|
|
});
|
|
}
|
|
|
|
activeChatProcessRegistry.clear();
|
|
chatRuntimeService.clearAll();
|
|
|
|
for (const client of this.clientStates.keys()) {
|
|
client.close();
|
|
}
|
|
|
|
this.wss.close();
|
|
}
|
|
|
|
async recoverInterruptedSessions() {
|
|
const recoverableRequests = await listRecoverableChatConversationRequests();
|
|
|
|
if (recoverableRequests.length === 0) {
|
|
return {
|
|
sessionCount: 0,
|
|
restartedCount: 0,
|
|
requeuedCount: 0,
|
|
};
|
|
}
|
|
|
|
const requestsBySession = new Map<string, typeof recoverableRequests>();
|
|
|
|
for (const item of recoverableRequests) {
|
|
const existing = requestsBySession.get(item.sessionId);
|
|
|
|
if (existing) {
|
|
existing.push(item);
|
|
} else {
|
|
requestsBySession.set(item.sessionId, [item]);
|
|
}
|
|
}
|
|
|
|
let restartedCount = 0;
|
|
let requeuedCount = 0;
|
|
|
|
for (const [sessionId, items] of requestsBySession.entries()) {
|
|
const session = this.getOrCreateSession(sessionId, items[0]?.clientId ?? null);
|
|
const primaryItem =
|
|
items.find((item) => item.requestId === item.currentRequestId && item.currentJobStatus === 'started') ??
|
|
items.find((item) => item.status === 'started') ??
|
|
items[0];
|
|
|
|
session.clientId = primaryItem?.clientId?.trim() || session.clientId;
|
|
session.context = {
|
|
pageId: null,
|
|
pageTitle: '',
|
|
topMenu: '',
|
|
focusedComponentId: null,
|
|
pageUrl: '',
|
|
chatTypeId: primaryItem?.chatTypeId ?? primaryItem?.lastChatTypeId ?? null,
|
|
chatTypeLabel: primaryItem?.contextLabel ?? '',
|
|
chatTypeDescription: primaryItem?.contextDescription ?? '',
|
|
};
|
|
|
|
for (const item of items) {
|
|
if (item.requestId === primaryItem?.requestId) {
|
|
continue;
|
|
}
|
|
|
|
const requestedAtMs = parseRequestedAtMs(item.createdAt);
|
|
session.queue.push({
|
|
requestId: item.requestId,
|
|
text: item.userText,
|
|
mode: 'queue',
|
|
requestedAtMs,
|
|
context: session.context ? cloneChatContext(session.context) : null,
|
|
});
|
|
chatRuntimeService.enqueueJob({
|
|
sessionId,
|
|
requestId: item.requestId,
|
|
mode: 'queue',
|
|
text: item.userText,
|
|
});
|
|
chatRuntimeService.appendLog(item.requestId, '워크서버 재기동 후 대기열 복구를 준비합니다.');
|
|
requeuedCount += 1;
|
|
}
|
|
|
|
if (!primaryItem) {
|
|
continue;
|
|
}
|
|
|
|
restartedCount += 1;
|
|
void this.executeRequest(session, {
|
|
requestId: primaryItem.requestId,
|
|
text: primaryItem.userText,
|
|
mode: 'queue',
|
|
requestedAtMs: parseRequestedAtMs(primaryItem.createdAt),
|
|
context: session.context ? cloneChatContext(session.context) : null,
|
|
}).catch((error: unknown) => {
|
|
this.logger.error(
|
|
{ error, sessionId: session.sessionId, requestId: primaryItem.requestId },
|
|
'failed to recover interrupted chat request',
|
|
);
|
|
});
|
|
}
|
|
|
|
this.logger.info(
|
|
{
|
|
sessionCount: requestsBySession.size,
|
|
restartedCount,
|
|
requeuedCount,
|
|
},
|
|
'recovered interrupted chat sessions after work-server restart',
|
|
);
|
|
|
|
return {
|
|
sessionCount: requestsBySession.size,
|
|
restartedCount,
|
|
requeuedCount,
|
|
};
|
|
}
|
|
|
|
private getOrCreateSession(sessionId: string, clientId?: string | null) {
|
|
const existing = this.sessions.get(sessionId);
|
|
|
|
if (existing) {
|
|
if (clientId?.trim()) {
|
|
existing.clientId = clientId.trim();
|
|
}
|
|
return existing;
|
|
}
|
|
|
|
const nextSession: ChatSessionState = {
|
|
sessionId,
|
|
clientId: clientId?.trim() || null,
|
|
socket: null,
|
|
lastSeenAt: Date.now(),
|
|
isDeleted: false,
|
|
context: null,
|
|
queue: [],
|
|
activeRequestCount: 0,
|
|
pendingQueueReleaseEventId: null,
|
|
nextEventId: 1,
|
|
eventHistory: [],
|
|
messagePersistenceTail: Promise.resolve(),
|
|
watchedRuntimeRequestId: null,
|
|
};
|
|
this.sessions.set(sessionId, nextSession);
|
|
return nextSession;
|
|
}
|
|
|
|
private createSessionEnvelope(session: ChatSessionState, message: ChatOutboundPayload): ChatOutboundMessage {
|
|
return {
|
|
...message,
|
|
eventId: session.nextEventId++,
|
|
sessionId: session.sessionId,
|
|
};
|
|
}
|
|
|
|
private retainEnvelopeForReplay(session: ChatSessionState, envelope: ChatOutboundMessage) {
|
|
if (envelope.type === 'chat:init' || envelope.type === 'chat:status') {
|
|
return;
|
|
}
|
|
|
|
session.eventHistory.push(envelope);
|
|
|
|
if (session.eventHistory.length > CHAT_SESSION_EVENT_HISTORY_LIMIT) {
|
|
session.eventHistory.splice(0, session.eventHistory.length - CHAT_SESSION_EVENT_HISTORY_LIMIT);
|
|
}
|
|
}
|
|
|
|
private persistConversationMessage(session: ChatSessionState, message: ChatMessage) {
|
|
if (session.isDeleted) {
|
|
return Promise.resolve();
|
|
}
|
|
|
|
const nextPersistence = session.messagePersistenceTail
|
|
.catch(() => undefined)
|
|
.then(() =>
|
|
appendChatConversationMessage(
|
|
{
|
|
sessionId: session.sessionId,
|
|
clientId: session.clientId,
|
|
title: null,
|
|
contextLabel: session.context?.chatTypeLabel ?? null,
|
|
contextDescription: session.context?.chatTypeDescription ?? null,
|
|
notifyOffline: undefined,
|
|
},
|
|
{
|
|
sessionId: session.sessionId,
|
|
messageId: message.id,
|
|
author: message.author,
|
|
text: message.text,
|
|
timestamp: message.timestamp,
|
|
clientRequestId: message.clientRequestId ?? null,
|
|
parts: message.parts ?? [],
|
|
},
|
|
),
|
|
);
|
|
|
|
session.messagePersistenceTail = nextPersistence.catch((error: unknown) => {
|
|
this.logger.error(error, 'failed to persist chat message');
|
|
});
|
|
|
|
return session.messagePersistenceTail;
|
|
}
|
|
|
|
private sendToSession(
|
|
session: ChatSessionState,
|
|
message: ChatOutboundPayload,
|
|
options?: {
|
|
skipOfflineNotification?: boolean;
|
|
},
|
|
) {
|
|
if (session.isDeleted) {
|
|
const normalizedDeletedMessage =
|
|
message.type === 'chat:message'
|
|
? {
|
|
...message,
|
|
payload: normalizeStructuredChatMessage(message.payload),
|
|
}
|
|
: message;
|
|
return this.createSessionEnvelope(session, normalizedDeletedMessage);
|
|
}
|
|
|
|
const normalizedMessage =
|
|
message.type === 'chat:message'
|
|
? {
|
|
...message,
|
|
payload: normalizeStructuredChatMessage(message.payload),
|
|
}
|
|
: message;
|
|
const envelope = this.createSessionEnvelope(session, normalizedMessage);
|
|
this.retainEnvelopeForReplay(session, envelope);
|
|
|
|
sendSocketEnvelope(this.logger, session.socket, envelope, 'failed to send websocket session envelope');
|
|
|
|
if (normalizedMessage.type === 'chat:message') {
|
|
this.persistConversationMessage(session, normalizedMessage.payload);
|
|
|
|
if (normalizedMessage.payload.author === 'codex' && options?.skipOfflineNotification !== true) {
|
|
void this.sendOfflineNotificationBestEffort(session, normalizedMessage.payload);
|
|
}
|
|
}
|
|
|
|
return envelope;
|
|
}
|
|
|
|
private async sendOfflineNotificationBestEffort(session: ChatSessionState, message: ChatMessage) {
|
|
try {
|
|
await this.sendOfflineNotificationIfNeeded(session, message);
|
|
} catch (error: unknown) {
|
|
this.logger.error(error, 'failed to send offline chat notification; request processing will continue');
|
|
}
|
|
}
|
|
|
|
private updateMessageInSession(session: ChatSessionState, message: ChatMessage) {
|
|
const normalizedMessage = normalizeStructuredChatMessage(message);
|
|
const envelope = this.createSessionEnvelope(session, {
|
|
type: 'chat:message:update',
|
|
payload: normalizedMessage,
|
|
});
|
|
this.retainEnvelopeForReplay(session, envelope);
|
|
|
|
sendSocketEnvelope(this.logger, session.socket, envelope, 'failed to send websocket message update envelope');
|
|
|
|
// Streaming codex deltas and synthesized activity summaries are transient UI state.
|
|
// Persist only the final chat message / activity rows to avoid long DB tails that
|
|
// can keep a finished request looking "running" until every intermediate update flushes.
|
|
if (shouldPersistMessageUpdate(normalizedMessage)) {
|
|
this.persistConversationMessage(session, normalizedMessage);
|
|
}
|
|
|
|
return envelope;
|
|
}
|
|
|
|
private broadcastRuntimeSnapshot(snapshot = chatRuntimeService.getSnapshot()) {
|
|
for (const session of this.sessions.values()) {
|
|
this.sendToSession(session, {
|
|
type: 'chat:runtime',
|
|
payload: snapshot,
|
|
});
|
|
|
|
this.pushRuntimeDetail(session);
|
|
}
|
|
}
|
|
|
|
private broadcastNotificationMessageChange(event: NotificationMessageChangeEvent) {
|
|
for (const session of this.sessions.values()) {
|
|
const payload =
|
|
event.action === 'deleted'
|
|
? {
|
|
action: 'deleted' as const,
|
|
itemId: event.id,
|
|
}
|
|
: {
|
|
action: event.action,
|
|
itemId: event.item.id,
|
|
category: event.item.category,
|
|
read: event.item.read,
|
|
};
|
|
const envelope = this.createSessionEnvelope(session, {
|
|
type: 'notification:messages-updated',
|
|
payload,
|
|
});
|
|
sendSocketEnvelope(this.logger, session.socket, envelope, 'failed to send notification message update envelope');
|
|
}
|
|
}
|
|
|
|
getSessionClientIdMap() {
|
|
return new Map(
|
|
[...this.sessions.entries()].map(([sessionId, session]) => [sessionId, session.clientId?.trim() || null]),
|
|
);
|
|
}
|
|
|
|
private pushRuntimeDetail(session: ChatSessionState) {
|
|
const requestId = session.watchedRuntimeRequestId?.trim();
|
|
|
|
if (!requestId) {
|
|
return;
|
|
}
|
|
|
|
this.sendToSession(session, {
|
|
type: 'chat:runtime:detail',
|
|
payload: chatRuntimeService.getJobDetail(requestId),
|
|
});
|
|
}
|
|
|
|
private async cancelRuntimeJob(requestId: string) {
|
|
const execution = activeChatProcessRegistry.get(requestId);
|
|
const detail = chatRuntimeService.getJobDetail(requestId);
|
|
|
|
if (!execution && detail.item && detail.terminalStatus == null) {
|
|
chatRuntimeService.appendLog(requestId, '실행 준비 단계에서 취소 요청을 접수했습니다.');
|
|
this.cancelledRequestIds.add(requestId);
|
|
const session = this.findSessionByRequestId(requestId);
|
|
|
|
if (session) {
|
|
void upsertChatConversationRequest(session.sessionId, {
|
|
requestId,
|
|
status: 'cancelled',
|
|
statusMessage: '사용자 요청으로 실행 취소를 대기합니다.',
|
|
}).catch((error: unknown) => {
|
|
this.logger.warn(error, 'failed to persist pending chat request cancellation state');
|
|
});
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
if (!execution) {
|
|
return false;
|
|
}
|
|
|
|
chatRuntimeService.appendLog(requestId, '사용자 요청으로 실행 취소를 시도합니다.');
|
|
this.cancelledRequestIds.add(requestId);
|
|
const session = this.findSessionByRequestId(requestId);
|
|
|
|
if (session) {
|
|
void upsertChatConversationRequest(session.sessionId, {
|
|
requestId,
|
|
status: 'cancelled',
|
|
statusMessage: '사용자 요청으로 실행 취소를 시도합니다.',
|
|
}).catch((error: unknown) => {
|
|
this.logger.warn(error, 'failed to persist chat request cancellation state');
|
|
});
|
|
}
|
|
|
|
try {
|
|
const cancelled = await execution.cancel();
|
|
|
|
if (!cancelled && this.cancelledRequestIds.has(requestId)) {
|
|
chatRuntimeService.appendLog(requestId, '취소 신호를 재시도 대기 중입니다.');
|
|
return true;
|
|
}
|
|
|
|
return cancelled;
|
|
} catch (error) {
|
|
this.logger.warn(error, 'failed to cancel chat runtime job');
|
|
chatRuntimeService.appendLog(requestId, '실행 취소 요청에 실패했습니다.');
|
|
this.cancelledRequestIds.delete(requestId);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private async removeQueuedRuntimeJob(requestId: string) {
|
|
let removed = false;
|
|
let removedSessionId: string | null = null;
|
|
|
|
for (const session of this.sessions.values()) {
|
|
const nextQueue = session.queue.filter((item) => item.requestId !== requestId);
|
|
|
|
if (nextQueue.length === session.queue.length) {
|
|
continue;
|
|
}
|
|
|
|
session.queue = nextQueue;
|
|
removed = true;
|
|
removedSessionId = session.sessionId;
|
|
this.emitJobState(session, {
|
|
requestId,
|
|
status: 'completed',
|
|
mode: 'queue',
|
|
queueSize: session.queue.length,
|
|
message: '대기열에서 제거됨',
|
|
});
|
|
this.sendToSession(session, {
|
|
type: 'chat:message',
|
|
payload: createMessage('system', '대기열 요청이 관리 화면에서 제거되었습니다.'),
|
|
});
|
|
break;
|
|
}
|
|
|
|
if (!removed) {
|
|
return false;
|
|
}
|
|
|
|
chatRuntimeService.finishJob(requestId, 'removed');
|
|
if (removedSessionId) {
|
|
await upsertChatConversationRequest(removedSessionId, {
|
|
requestId,
|
|
status: 'removed',
|
|
statusMessage: '대기열에서 제거되었습니다.',
|
|
});
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private tryStartNextQueuedRequest(session: ChatSessionState) {
|
|
this.normalizeSessionExecutionState(session);
|
|
|
|
if (session.activeRequestCount > 0 || session.queue.length === 0 || session.pendingQueueReleaseEventId !== null) {
|
|
return;
|
|
}
|
|
|
|
const nextQueuedRequest = session.queue.shift();
|
|
|
|
if (!nextQueuedRequest) {
|
|
return;
|
|
}
|
|
|
|
void this.executeRequest(session, nextQueuedRequest).catch((error: unknown) => {
|
|
this.logger.error(error, 'queued chat reply build failed');
|
|
this.sendToSession(session, {
|
|
type: 'chat:error',
|
|
payload: {
|
|
message: '대기 중이던 채팅 요청 처리 중 오류가 발생했습니다.',
|
|
},
|
|
});
|
|
});
|
|
}
|
|
|
|
private normalizeSessionExecutionState(session: ChatSessionState) {
|
|
const snapshot = chatRuntimeService.getSnapshot();
|
|
const runtimeSession = snapshot.sessions.find((item) => item.sessionId === session.sessionId) ?? null;
|
|
const runtimeRunningCount = runtimeSession?.runningCount ?? 0;
|
|
const runtimeQueuedIds = new Set(
|
|
snapshot.queued.filter((item) => item.sessionId === session.sessionId).map((item) => item.requestId),
|
|
);
|
|
|
|
session.activeRequestCount = runtimeRunningCount;
|
|
session.queue = session.queue.filter((item) => runtimeQueuedIds.has(item.requestId));
|
|
|
|
if (runtimeRunningCount === 0) {
|
|
session.pendingQueueReleaseEventId = null;
|
|
}
|
|
}
|
|
|
|
private emitJobState(
|
|
session: ChatSessionState,
|
|
payload: {
|
|
requestId: string;
|
|
status: 'queued' | 'started' | 'completed' | 'failed';
|
|
mode: 'queue' | 'direct';
|
|
queueSize: number;
|
|
message: string;
|
|
},
|
|
) {
|
|
this.sendToSession(session, {
|
|
type: 'chat:job',
|
|
payload,
|
|
});
|
|
|
|
void updateChatConversationJobState(session.sessionId, {
|
|
requestId: payload.requestId,
|
|
status: payload.status,
|
|
message: payload.message,
|
|
queueSize: payload.queueSize,
|
|
clear: false,
|
|
}).catch((error: unknown) => {
|
|
this.logger.error(error, 'failed to persist chat job state');
|
|
});
|
|
|
|
const requestStatus =
|
|
payload.status === 'queued'
|
|
? 'queued'
|
|
: payload.status === 'started'
|
|
? 'started'
|
|
: payload.status === 'completed'
|
|
? 'completed'
|
|
: this.cancelledRequestIds.has(payload.requestId)
|
|
? 'cancelled'
|
|
: 'failed';
|
|
|
|
void upsertChatConversationRequest(session.sessionId, {
|
|
requestId: payload.requestId,
|
|
status: requestStatus,
|
|
statusMessage: payload.message,
|
|
}).catch((error: unknown) => {
|
|
this.logger.error(error, 'failed to persist chat request state');
|
|
});
|
|
}
|
|
|
|
private findSessionByRequestId(requestId: string) {
|
|
for (const session of this.sessions.values()) {
|
|
if (session.queue.some((item) => item.requestId === requestId)) {
|
|
return session;
|
|
}
|
|
|
|
if (
|
|
session.eventHistory.some((event) => {
|
|
if (event.type === 'chat:job') {
|
|
return event.payload.requestId === requestId;
|
|
}
|
|
|
|
if (event.type === 'chat:message' || event.type === 'chat:message:update') {
|
|
return event.payload.clientRequestId === requestId;
|
|
}
|
|
|
|
return false;
|
|
})
|
|
) {
|
|
return session;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private async sendOfflineNotificationIfNeeded(session: ChatSessionState, message: ChatMessage) {
|
|
if (!session.clientId?.trim()) {
|
|
return;
|
|
}
|
|
|
|
if (message.author !== 'codex' || isPreparingChatReply(message.text)) {
|
|
return;
|
|
}
|
|
|
|
const appOrigin = resolveChatContextAppOrigin(session.context);
|
|
const [conversation, appConfig] = await Promise.all([
|
|
getChatConversation(session.sessionId, session.clientId),
|
|
getAppConfigSnapshot(appOrigin),
|
|
]);
|
|
|
|
if (
|
|
!shouldSendOfflineChatNotification({
|
|
receiveRoomNotifications: appConfig.chat?.receiveRoomNotifications,
|
|
conversationNotifyOffline: conversation?.notifyOffline,
|
|
})
|
|
) {
|
|
return;
|
|
}
|
|
|
|
const requestOwnerClientId = message.clientRequestId?.trim()
|
|
? (await getChatConversationRequest(session.sessionId, message.clientRequestId).catch(() => null))
|
|
?.requesterClientId?.trim() || null
|
|
: null;
|
|
|
|
if (!requestOwnerClientId) {
|
|
return;
|
|
}
|
|
|
|
const preferredNotificationClientIds = await listChatConversationOfflineNotificationClientIds(session.sessionId, {
|
|
keepClientIds: [session.clientId, requestOwnerClientId],
|
|
}).catch(() => []);
|
|
const notificationCandidateClientIds = collectOfflineNotificationClientIds(session.clientId, [
|
|
requestOwnerClientId,
|
|
...preferredNotificationClientIds,
|
|
]);
|
|
const notificationTargetClientIds = notificationCandidateClientIds.filter((clientId) => {
|
|
const evaluation = evaluateChatClientActiveViewing(clientId, this.sessions.values());
|
|
logChatClientActiveViewingEvaluation(this.logger, clientId, evaluation);
|
|
return !evaluation.isActive;
|
|
});
|
|
|
|
if (!notificationTargetClientIds.length) {
|
|
this.logger.info(
|
|
{
|
|
sessionId: session.sessionId,
|
|
messageId: message.id,
|
|
requestOwnerClientId,
|
|
notificationCandidateClientIds,
|
|
},
|
|
'chat offline notification skipped because every target client is actively viewing',
|
|
);
|
|
return;
|
|
}
|
|
|
|
const notificationPayload = await this.buildOfflineChatNotificationPayload(
|
|
session,
|
|
message,
|
|
conversation?.title || '현재 채팅방',
|
|
);
|
|
|
|
if (!notificationPayload) {
|
|
return;
|
|
}
|
|
|
|
await this.createOfflineAppNotificationIfNeeded(notificationPayload, notificationTargetClientIds);
|
|
|
|
const result = await sendNotifications(
|
|
{
|
|
title: notificationPayload.title,
|
|
body: notificationPayload.body,
|
|
data: notificationPayload.data,
|
|
threadId: notificationPayload.threadId,
|
|
targetClientIds: notificationTargetClientIds,
|
|
},
|
|
{
|
|
disableIos: true,
|
|
},
|
|
);
|
|
|
|
if (!result.web.ok && !result.web.skipped) {
|
|
this.logger.warn(
|
|
{
|
|
sessionId: session.sessionId,
|
|
messageId: message.id,
|
|
targetClientIds: notificationTargetClientIds,
|
|
webPush: result.web,
|
|
},
|
|
'chat webpush delivery reported failures',
|
|
);
|
|
}
|
|
}
|
|
|
|
private async createOfflineAppNotificationIfNeeded(
|
|
payload: {
|
|
title: string;
|
|
body: string;
|
|
previewText: string;
|
|
metadata: Record<string, string>;
|
|
linkUrl: string;
|
|
},
|
|
targetClientIds: string[],
|
|
) {
|
|
await createNotificationMessage({
|
|
title: payload.title,
|
|
body: payload.body,
|
|
category: 'chat',
|
|
source: 'codex-live',
|
|
priority: 'normal',
|
|
metadata: {
|
|
...payload.metadata,
|
|
targetClientIds,
|
|
linkUrl: payload.linkUrl,
|
|
linkLabel: '채팅 바로 열기',
|
|
previewText: payload.previewText,
|
|
},
|
|
});
|
|
}
|
|
|
|
private async buildOfflineChatNotificationPayload(
|
|
session: ChatSessionState,
|
|
message: ChatMessage,
|
|
conversationTitle: string,
|
|
) {
|
|
const answerText = String(message.text ?? '').trim();
|
|
|
|
if (!answerText || isPreparingChatReply(answerText)) {
|
|
return null;
|
|
}
|
|
|
|
const linkUrl = buildChatNotificationTargetUrl(session.context, session.sessionId);
|
|
const requests = message.clientRequestId?.trim()
|
|
? await listChatConversationRequests(session.sessionId, 200).catch(() => [])
|
|
: [];
|
|
const matchingRequest =
|
|
requests.find((request) => request.requestId === message.clientRequestId) ??
|
|
requests.find((request) => request.responseMessageId === message.id) ??
|
|
null;
|
|
const questionText = matchingRequest?.userText?.trim() || '';
|
|
const fallback = createChatNotificationPreview(answerText) || `${conversationTitle} 채팅방에 새 응답이 도착했습니다.`;
|
|
const body = createChatQuestionAnswerNotificationBody({
|
|
questionText,
|
|
answerText,
|
|
fallback,
|
|
});
|
|
const previewText = createChatQuestionOnlyNotificationPreview(questionText, fallback);
|
|
|
|
if (!body.trim()) {
|
|
return null;
|
|
}
|
|
|
|
const metadata = {
|
|
category: 'chat',
|
|
sessionId: session.sessionId,
|
|
conversationTitle,
|
|
messageId: String(message.id),
|
|
messageTimestamp: message.timestamp,
|
|
questionText: normalizeNotificationDetailText(questionText) ?? '',
|
|
answerText: normalizeNotificationDetailText(answerText) ?? '',
|
|
targetUrl: linkUrl,
|
|
notificationKey: `chat:${session.sessionId}:${message.id}`,
|
|
type: 'chat-reply',
|
|
suppressIfVisible: 'true',
|
|
};
|
|
|
|
return {
|
|
title: 'Codex Live 새 메시지',
|
|
body,
|
|
previewText,
|
|
linkUrl,
|
|
threadId: `chat:${session.sessionId}`,
|
|
data: metadata,
|
|
metadata,
|
|
};
|
|
}
|
|
|
|
private replaySessionHistory(session: ChatSessionState, lastEventId: number) {
|
|
if (session.isDeleted || !Number.isFinite(lastEventId) || lastEventId <= 0 || session.eventHistory.length === 0) {
|
|
return;
|
|
}
|
|
|
|
const pendingEnvelopes = session.eventHistory.filter((envelope) => envelope.eventId > lastEventId);
|
|
|
|
for (const envelope of pendingEnvelopes) {
|
|
sendSocketEnvelope(this.logger, session.socket, envelope, 'failed to replay websocket session history envelope');
|
|
}
|
|
}
|
|
|
|
private async initializeSession(session: ChatSessionState) {
|
|
if (session.isDeleted) {
|
|
return;
|
|
}
|
|
|
|
await session.messagePersistenceTail.catch(() => undefined);
|
|
|
|
const messages = await listChatConversationMessages(session.sessionId, { limit: 500 });
|
|
|
|
const initEnvelope = this.createSessionEnvelope(session, {
|
|
type: 'chat:init',
|
|
payload: {
|
|
messages,
|
|
},
|
|
});
|
|
|
|
sendSocketEnvelope(this.logger, session.socket, initEnvelope, 'failed to send websocket init envelope');
|
|
|
|
const statusEnvelope = this.createSessionEnvelope(session, {
|
|
type: 'chat:status',
|
|
payload: {
|
|
connectedAt: new Date().toISOString(),
|
|
},
|
|
});
|
|
|
|
sendSocketEnvelope(this.logger, session.socket, statusEnvelope, 'failed to send websocket status envelope');
|
|
|
|
this.sendToSession(session, {
|
|
type: 'chat:runtime',
|
|
payload: chatRuntimeService.getSnapshot(),
|
|
});
|
|
}
|
|
|
|
private async handleConnection(socket: WebSocket, request: IncomingMessage) {
|
|
const origin = request.headers.host ? `http://${request.headers.host}` : 'http://localhost';
|
|
const url = new URL(request.url ?? '/', origin);
|
|
|
|
if (!hasAuthorizedChatSocketAccess(request, url)) {
|
|
closeSocketSafely(this.logger, socket, 'failed to close unauthorized chat websocket session', 1008, 'unauthorized');
|
|
return;
|
|
}
|
|
|
|
const requestedSessionId = url.searchParams.get('sessionId')?.trim() || createRequestId();
|
|
const clientId = url.searchParams.get('clientId')?.trim() || null;
|
|
const lastEventIdRaw = Number(url.searchParams.get('lastEventId') ?? 0);
|
|
const lastEventId = Number.isFinite(lastEventIdRaw) && lastEventIdRaw > 0 ? lastEventIdRaw : 0;
|
|
const session = this.getOrCreateSession(requestedSessionId, clientId);
|
|
|
|
if (session.socket && session.socket !== socket) {
|
|
closeSocketSafely(this.logger, session.socket, 'failed to close superseded websocket session');
|
|
}
|
|
|
|
session.socket = socket;
|
|
session.lastSeenAt = Date.now();
|
|
this.clientStates.set(socket, session);
|
|
|
|
socket.on('message', (raw: RawData) => {
|
|
this.handleMessage(socket, raw);
|
|
});
|
|
|
|
socket.on('close', () => {
|
|
this.clientStates.delete(socket);
|
|
if (session.socket === socket) {
|
|
session.socket = null;
|
|
}
|
|
});
|
|
|
|
socket.on('error', (error: Error) => {
|
|
this.logger.error(error, 'chat websocket error');
|
|
this.clientStates.delete(socket);
|
|
if (session.socket === socket) {
|
|
session.socket = null;
|
|
}
|
|
});
|
|
|
|
await this.initializeSession(session);
|
|
this.replaySessionHistory(session, lastEventId);
|
|
}
|
|
|
|
async forgetSession(sessionId: string) {
|
|
const normalizedSessionId = sessionId.trim();
|
|
|
|
if (!normalizedSessionId) {
|
|
return;
|
|
}
|
|
|
|
const session = this.sessions.get(normalizedSessionId);
|
|
const runtimeSnapshot = chatRuntimeService.getSnapshot();
|
|
const runtimeRequestIds = new Set(
|
|
[...runtimeSnapshot.running, ...runtimeSnapshot.queued, ...runtimeSnapshot.recent]
|
|
.filter((item) => item.sessionId === normalizedSessionId)
|
|
.map((item) => item.requestId),
|
|
);
|
|
|
|
if (session) {
|
|
session.isDeleted = true;
|
|
session.queue = [];
|
|
session.eventHistory = [];
|
|
session.pendingQueueReleaseEventId = null;
|
|
session.watchedRuntimeRequestId = null;
|
|
session.activeRequestCount = 0;
|
|
|
|
if (session.socket) {
|
|
this.clientStates.delete(session.socket);
|
|
closeSocketSafely(this.logger, session.socket, 'failed to close deleted chat websocket session');
|
|
session.socket = null;
|
|
}
|
|
|
|
this.sessions.delete(normalizedSessionId);
|
|
}
|
|
|
|
for (const requestId of runtimeRequestIds) {
|
|
const detail = chatRuntimeService.getJobDetail(requestId);
|
|
|
|
if (detail.availableActions.cancel) {
|
|
try {
|
|
await this.cancelRuntimeJob(requestId);
|
|
} catch {
|
|
// ignore and hard-clear runtime state below
|
|
}
|
|
} else if (detail.availableActions.remove) {
|
|
try {
|
|
await this.removeQueuedRuntimeJob(requestId);
|
|
} catch {
|
|
// ignore and hard-clear runtime state below
|
|
}
|
|
}
|
|
|
|
activeChatProcessRegistry.delete(requestId);
|
|
this.cancelledRequestIds.delete(requestId);
|
|
}
|
|
|
|
chatRuntimeService.clearSession(normalizedSessionId);
|
|
}
|
|
|
|
resetSessionData(sessionId: string) {
|
|
const normalizedSessionId = sessionId.trim();
|
|
|
|
if (!normalizedSessionId) {
|
|
return;
|
|
}
|
|
|
|
const session = this.sessions.get(normalizedSessionId);
|
|
|
|
if (!session) {
|
|
return;
|
|
}
|
|
|
|
session.queue = [];
|
|
session.eventHistory = [];
|
|
session.pendingQueueReleaseEventId = null;
|
|
session.watchedRuntimeRequestId = null;
|
|
session.activeRequestCount = 0;
|
|
}
|
|
|
|
private handleMessage(socket: WebSocket, raw: RawData) {
|
|
try {
|
|
const message = JSON.parse(raw.toString()) as ChatInboundMessage;
|
|
const session = this.clientStates.get(socket);
|
|
|
|
if (session) {
|
|
session.lastSeenAt = Date.now();
|
|
}
|
|
|
|
if (message.type === 'context:update') {
|
|
this.handleContextUpdate(socket, message.payload);
|
|
return;
|
|
}
|
|
|
|
if (message.type === 'presence:ping') {
|
|
return;
|
|
}
|
|
|
|
if (message.type === 'event:received') {
|
|
const receivedEventId = Math.round(Number(message.payload?.eventId ?? 0));
|
|
|
|
if (
|
|
session &&
|
|
Number.isFinite(receivedEventId) &&
|
|
receivedEventId > 0 &&
|
|
session.pendingQueueReleaseEventId !== null &&
|
|
receivedEventId >= session.pendingQueueReleaseEventId
|
|
) {
|
|
session.pendingQueueReleaseEventId = null;
|
|
this.tryStartNextQueuedRequest(session);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (message.type === 'message:send') {
|
|
void this.handleUserMessage(
|
|
socket,
|
|
message.payload.text,
|
|
message.payload.requestId,
|
|
message.payload.mode === 'direct' ? 'direct' : 'queue',
|
|
{
|
|
chatTypeId: message.payload.chatTypeId ?? null,
|
|
chatTypeLabel: message.payload.chatTypeLabel,
|
|
chatTypeDescription: message.payload.chatTypeDescription,
|
|
chatTypeBaseDescription: message.payload.chatTypeBaseDescription,
|
|
defaultContextIds: message.payload.defaultContextIds,
|
|
defaultContexts: message.payload.defaultContexts,
|
|
customContextTitle: message.payload.customContextTitle,
|
|
customContextContent: message.payload.customContextContent,
|
|
},
|
|
{
|
|
omitPromptHistory: message.payload.omitPromptHistory === true,
|
|
},
|
|
).catch((error: unknown) => {
|
|
this.logger.error(error, 'chat reply build failed');
|
|
const session = this.clientStates.get(socket);
|
|
|
|
if (!session) {
|
|
return;
|
|
}
|
|
|
|
this.sendToSession(session, {
|
|
type: 'chat:error',
|
|
payload: {
|
|
message:
|
|
error instanceof Error && error.message.trim()
|
|
? error.message.trim()
|
|
: '채팅 응답을 만드는 중 오류가 발생했습니다.',
|
|
},
|
|
});
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (message.type === 'runtime:watch') {
|
|
if (!session) {
|
|
return;
|
|
}
|
|
|
|
session.watchedRuntimeRequestId = message.payload?.requestId?.trim() || null;
|
|
this.pushRuntimeDetail(session);
|
|
}
|
|
} catch (error) {
|
|
this.logger.warn(error, 'invalid chat websocket payload');
|
|
const session = this.clientStates.get(socket);
|
|
|
|
if (!session) {
|
|
return;
|
|
}
|
|
|
|
this.sendToSession(session, {
|
|
type: 'chat:error',
|
|
payload: {
|
|
message: '채팅 메시지를 처리하지 못했습니다.',
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
private handleContextUpdate(socket: WebSocket, context: ChatContext) {
|
|
const state = this.clientStates.get(socket);
|
|
|
|
if (!state) {
|
|
return;
|
|
}
|
|
|
|
const previousFocus = state.context?.focusedComponentId;
|
|
const previousContextLabel = state.context?.chatTypeLabel ?? null;
|
|
const previousContextDescription = state.context?.chatTypeDescription ?? null;
|
|
state.context = context;
|
|
const nextContextLabel = context.chatTypeLabel ?? null;
|
|
const nextContextDescription = context.chatTypeDescription ?? null;
|
|
|
|
if (previousContextLabel !== nextContextLabel || previousContextDescription !== nextContextDescription) {
|
|
void updateChatConversationContext(state.sessionId, {
|
|
clientId: state.clientId,
|
|
contextLabel: nextContextLabel,
|
|
contextDescription: nextContextDescription,
|
|
}).catch((error: unknown) => {
|
|
this.logger.error(error, 'failed to persist chat context');
|
|
});
|
|
}
|
|
|
|
if (context.focusedComponentId && context.focusedComponentId !== previousFocus) {
|
|
this.sendToSession(state, {
|
|
type: 'chat:message',
|
|
payload: createMessage('codex', `선택 포커스가 ${context.focusedComponentId}로 이동했습니다. 관련 문맥을 반영합니다.`),
|
|
});
|
|
}
|
|
}
|
|
|
|
private async handleUserMessage(
|
|
socket: WebSocket,
|
|
text: string,
|
|
requestId?: string,
|
|
mode: 'queue' | 'direct' = 'queue',
|
|
contextOverride?: Partial<ChatContext> | null,
|
|
requestOptions?: {
|
|
omitPromptHistory?: boolean;
|
|
},
|
|
) {
|
|
const trimmed = text.trim();
|
|
|
|
if (!trimmed) {
|
|
return;
|
|
}
|
|
|
|
const state = this.clientStates.get(socket);
|
|
|
|
if (!state) {
|
|
return;
|
|
}
|
|
|
|
if (contextOverride) {
|
|
const mergedContext = {
|
|
...(state.context ?? {
|
|
pageId: null,
|
|
pageTitle: '',
|
|
topMenu: '',
|
|
focusedComponentId: null,
|
|
pageUrl: '',
|
|
}),
|
|
...contextOverride,
|
|
};
|
|
state.context = (await resolveCodexLiveChatContext(mergedContext, state.sessionId)) ?? mergedContext;
|
|
void updateChatConversationContext(state.sessionId, {
|
|
clientId: state.clientId,
|
|
chatTypeId: state.context.chatTypeId ?? null,
|
|
lastChatTypeId: state.context.chatTypeId ?? null,
|
|
contextLabel: state.context.chatTypeLabel ?? null,
|
|
contextDescription: state.context.chatTypeDescription ?? null,
|
|
}).catch((error: unknown) => {
|
|
this.logger.error(error, 'failed to persist chat context from message send');
|
|
});
|
|
}
|
|
|
|
this.normalizeSessionExecutionState(state);
|
|
|
|
const nextRequestId = requestId?.trim() || createRequestId();
|
|
const requestedAtMs = Date.now();
|
|
|
|
const request = {
|
|
requestId: nextRequestId,
|
|
text: trimmed,
|
|
mode,
|
|
requestedAtMs,
|
|
omitPromptHistory: requestOptions?.omitPromptHistory === true,
|
|
context: cloneChatContext(state.context),
|
|
};
|
|
|
|
if (mode === 'queue' && (state.activeRequestCount > 0 || state.queue.length > 0)) {
|
|
const queuedUserMessage = {
|
|
...createMessage('user', trimmed, nextRequestId),
|
|
timestamp: formatTime(new Date(requestedAtMs)),
|
|
};
|
|
|
|
this.sendToSession(state, {
|
|
type: 'chat:message',
|
|
payload: queuedUserMessage,
|
|
});
|
|
state.queue.push(request);
|
|
chatRuntimeService.enqueueJob({
|
|
sessionId: state.sessionId,
|
|
requestId: nextRequestId,
|
|
mode,
|
|
text: trimmed,
|
|
});
|
|
chatRuntimeService.registerQueuedControl(nextRequestId, {
|
|
remove: () => this.removeQueuedRuntimeJob(nextRequestId),
|
|
});
|
|
this.emitJobState(state, {
|
|
requestId: nextRequestId,
|
|
status: 'queued',
|
|
mode,
|
|
queueSize: state.queue.length,
|
|
message: `대기열 ${state.queue.length}건`,
|
|
});
|
|
void upsertChatConversationRequest(state.sessionId, {
|
|
requestId: nextRequestId,
|
|
status: 'queued',
|
|
statusMessage: `대기열 ${state.queue.length}건`,
|
|
userMessageId: queuedUserMessage.id,
|
|
userText: trimmed,
|
|
}).catch((error: unknown) => {
|
|
this.logger.error(error, 'failed to persist queued chat request');
|
|
});
|
|
return;
|
|
}
|
|
|
|
await this.executeRequest(state, request);
|
|
}
|
|
|
|
private async executeRequest(
|
|
session: ChatSessionState,
|
|
request: {
|
|
requestId: string;
|
|
text: string;
|
|
mode: 'queue' | 'direct';
|
|
requestedAtMs: number;
|
|
omitPromptHistory?: boolean;
|
|
context: ChatContext | null;
|
|
},
|
|
) {
|
|
let terminalStatus: 'completed' | 'failed' | 'cancelled' = 'completed';
|
|
let hasAnnouncedStreaming = false;
|
|
const compactActivityLineMap = new Map<number, string>();
|
|
session.activeRequestCount += 1;
|
|
const existingRequest = await getChatConversationRequest(session.sessionId, request.requestId);
|
|
const hasStoredUserMessage = existingRequest?.userMessageId != null;
|
|
|
|
if (!hasStoredUserMessage) {
|
|
this.sendToSession(session, {
|
|
type: 'chat:message',
|
|
payload: {
|
|
...createMessage('user', request.text, request.requestId),
|
|
timestamp: formatTime(new Date(request.requestedAtMs)),
|
|
},
|
|
});
|
|
}
|
|
|
|
const appendActivityLine = (line: string) => {
|
|
const compactEntry = createCompactActivityLogEntry(line);
|
|
|
|
if (!compactEntry) {
|
|
return;
|
|
}
|
|
|
|
const previousLine = compactActivityLineMap.get(compactEntry.lineNo);
|
|
|
|
if (previousLine === compactEntry.line) {
|
|
return;
|
|
}
|
|
|
|
compactActivityLineMap.set(compactEntry.lineNo, compactEntry.line);
|
|
const activityLines = Array.from(compactActivityLineMap.entries())
|
|
.sort((left, right) => left[0] - right[0])
|
|
.map(([, activityLine]) => activityLine);
|
|
|
|
void appendChatConversationActivityLine(
|
|
session.sessionId,
|
|
request.requestId,
|
|
compactEntry.line,
|
|
compactEntry.lineNo,
|
|
).catch((error: unknown) => {
|
|
this.logger.warn(error, 'failed to persist compact chat activity line');
|
|
});
|
|
this.sendToSession(session, {
|
|
type: 'chat:activity',
|
|
payload: {
|
|
requestId: request.requestId,
|
|
line: compactEntry.line,
|
|
lineCount: activityLines.length,
|
|
lineNo: compactEntry.lineNo,
|
|
},
|
|
});
|
|
const activityMessage = createActivityLogMessage(request.requestId, activityLines);
|
|
|
|
if (activityMessage) {
|
|
this.updateMessageInSession(session, activityMessage);
|
|
}
|
|
};
|
|
|
|
chatRuntimeService.startJob({
|
|
sessionId: session.sessionId,
|
|
requestId: request.requestId,
|
|
mode: request.mode,
|
|
text: request.text,
|
|
});
|
|
chatRuntimeService.registerRunningControl(request.requestId, {
|
|
cancel: () => this.cancelRuntimeJob(request.requestId),
|
|
});
|
|
chatRuntimeService.appendLog(request.requestId, `요청을 처리합니다. mode=${request.mode}`);
|
|
appendActivityLine(`# 상태: 요청을 처리합니다. mode=${request.mode}`);
|
|
this.emitJobState(session, {
|
|
requestId: request.requestId,
|
|
status: 'started',
|
|
mode: request.mode,
|
|
queueSize: session.queue.length,
|
|
message:
|
|
request.mode === 'direct'
|
|
? '즉시 요청 실행 중'
|
|
: `요청 처리 중${session.queue.length > 0 ? ` · 대기열 ${session.queue.length}건` : ''}`,
|
|
});
|
|
|
|
this.sendToSession(session, {
|
|
type: 'chat:message',
|
|
payload: createMessage(
|
|
'system',
|
|
request.mode === 'direct'
|
|
? '즉시 요청 실행 중입니다.'
|
|
: `요청 실행 중입니다.${session.queue.length > 0 ? ` 남은 대기열 ${session.queue.length}건` : ''}`,
|
|
request.requestId,
|
|
),
|
|
});
|
|
|
|
const stopProgressTimer = () => {
|
|
if (progressTimer !== null) {
|
|
clearTimeout(progressTimer);
|
|
progressTimer = null;
|
|
}
|
|
};
|
|
const progressMessages = buildProgressMessages(request.text);
|
|
let progressIndex = progressMessages.length > 1 ? 1 : 0;
|
|
let lastProgressMessage = progressMessages[0] ?? '';
|
|
let lastMeaningfulProgressSummary = '';
|
|
let progressTimer: ReturnType<typeof setTimeout> | null = null;
|
|
const emitSystemProgressMessage = (nextMessage: string, options?: { appendActivity?: boolean }) => {
|
|
const normalizedMessage = normalizeProgressSummary(nextMessage);
|
|
|
|
if (!normalizedMessage || normalizedMessage === lastProgressMessage) {
|
|
return false;
|
|
}
|
|
|
|
lastProgressMessage = normalizedMessage;
|
|
chatRuntimeService.appendLog(request.requestId, normalizedMessage);
|
|
|
|
if (options?.appendActivity !== false) {
|
|
appendActivityLine(`# 진행: ${normalizedMessage}`);
|
|
}
|
|
|
|
this.sendToSession(session, {
|
|
type: 'chat:message',
|
|
payload: createMessage('system', normalizedMessage, request.requestId),
|
|
});
|
|
return true;
|
|
};
|
|
const scheduleFallbackProgressMessage = () => {
|
|
if (progressIndex >= progressMessages.length) {
|
|
return;
|
|
}
|
|
|
|
stopProgressTimer();
|
|
progressTimer = setTimeout(() => {
|
|
const nextMessage = progressMessages[progressIndex] ?? '';
|
|
|
|
if (!nextMessage || lastMeaningfulProgressSummary) {
|
|
stopProgressTimer();
|
|
return;
|
|
}
|
|
|
|
if (emitSystemProgressMessage(nextMessage)) {
|
|
progressIndex += 1;
|
|
}
|
|
|
|
stopProgressTimer();
|
|
}, 2200);
|
|
};
|
|
|
|
const codexReplyMessage = createMessage('codex', '', request.requestId);
|
|
|
|
try {
|
|
chatRuntimeService.appendLog(request.requestId, '요청 분석을 시작합니다.');
|
|
appendActivityLine('# 진행: 요청 분석을 시작합니다.');
|
|
this.sendToSession(session, {
|
|
type: 'chat:message',
|
|
payload: createMessage('system', progressMessages[0] ?? '요청을 분석하고 있습니다.', request.requestId),
|
|
});
|
|
scheduleFallbackProgressMessage();
|
|
this.updateMessageInSession(session, {
|
|
...codexReplyMessage,
|
|
text: '응답을 준비하고 있습니다...',
|
|
timestamp: resolveResponseTimestamp(request.requestedAtMs),
|
|
});
|
|
|
|
const reply = await buildCodexReply(
|
|
request.context ?? session.context ?? null,
|
|
request.text,
|
|
session.sessionId,
|
|
request.requestId,
|
|
{
|
|
omitPromptHistory: request.omitPromptHistory === true,
|
|
requestedAt: new Date(request.requestedAtMs),
|
|
},
|
|
(partialReply) => {
|
|
stopProgressTimer();
|
|
if (!hasAnnouncedStreaming) {
|
|
hasAnnouncedStreaming = true;
|
|
chatRuntimeService.appendLog(request.requestId, '응답을 실시간으로 전송 중입니다.');
|
|
appendActivityLine('# 진행: 응답을 실시간으로 전송 중입니다.');
|
|
}
|
|
this.updateMessageInSession(session, {
|
|
...codexReplyMessage,
|
|
text: partialReply,
|
|
timestamp: resolveResponseTimestamp(request.requestedAtMs),
|
|
});
|
|
},
|
|
(activityLine) => {
|
|
appendActivityLine(activityLine);
|
|
const activitySummary = summarizeActivityProgressLine(activityLine);
|
|
|
|
if (activitySummary && activitySummary !== lastMeaningfulProgressSummary) {
|
|
lastMeaningfulProgressSummary = activitySummary;
|
|
stopProgressTimer();
|
|
emitSystemProgressMessage(activitySummary, { appendActivity: false });
|
|
}
|
|
},
|
|
() => this.cancelledRequestIds.has(request.requestId),
|
|
);
|
|
chatRuntimeService.appendLog(request.requestId, '응답 생성이 완료되었습니다.');
|
|
appendActivityLine('# 상태: 응답 생성이 완료되었습니다.');
|
|
|
|
const finalCodexReplyMessage = {
|
|
...codexReplyMessage,
|
|
...(() => {
|
|
const extracted = extractChatMessageParts(reply);
|
|
return {
|
|
text: extracted.strippedText,
|
|
parts: extracted.parts,
|
|
};
|
|
})(),
|
|
timestamp: resolveResponseTimestamp(request.requestedAtMs),
|
|
};
|
|
|
|
this.sendToSession(
|
|
session,
|
|
{
|
|
type: 'chat:message',
|
|
payload: finalCodexReplyMessage,
|
|
},
|
|
{
|
|
skipOfflineNotification: true,
|
|
},
|
|
);
|
|
|
|
// Final replies must be durably stored before the request is marked complete,
|
|
// otherwise replay/reload can be stuck on the placeholder text.
|
|
await this.persistConversationMessage(session, finalCodexReplyMessage);
|
|
await upsertChatConversationRequest(session.sessionId, {
|
|
requestId: request.requestId,
|
|
status: 'completed',
|
|
statusMessage: '요청 처리 완료',
|
|
responseMessageId: finalCodexReplyMessage.id,
|
|
responseText: finalCodexReplyMessage.text,
|
|
});
|
|
await refreshChatSessionReferenceForRequest({
|
|
sessionId: session.sessionId,
|
|
requestId: request.requestId,
|
|
context: request.context ?? session.context ?? null,
|
|
input: request.text,
|
|
requestStatus: 'completed',
|
|
requestedAt: new Date(request.requestedAtMs),
|
|
completedAt: new Date(),
|
|
});
|
|
|
|
const terminalMessageEnvelope = this.sendToSession(session, {
|
|
type: 'chat:message',
|
|
payload: createMessage(
|
|
'system',
|
|
request.mode === 'direct'
|
|
? '즉시 요청 처리가 끝났습니다.'
|
|
: `요청 처리가 끝났습니다.${session.queue.length > 0 ? ` 대기열 ${session.queue.length}건이 이어집니다.` : ''}`,
|
|
request.requestId,
|
|
),
|
|
});
|
|
session.pendingQueueReleaseEventId = terminalMessageEnvelope.eventId;
|
|
this.emitJobState(session, {
|
|
requestId: request.requestId,
|
|
status: 'completed',
|
|
mode: request.mode,
|
|
queueSize: session.queue.length,
|
|
message: '요청 처리 완료',
|
|
});
|
|
chatRuntimeService.finishJob(request.requestId, 'completed');
|
|
await this.sendOfflineNotificationBestEffort(session, finalCodexReplyMessage);
|
|
} catch (error) {
|
|
const wasCancelled = this.cancelledRequestIds.has(request.requestId);
|
|
terminalStatus = wasCancelled ? 'cancelled' : 'failed';
|
|
const failureResponseText =
|
|
error instanceof ChatRuntimeExecutionError ? error.responseText : '';
|
|
|
|
if (failureResponseText) {
|
|
const extractedFailureReply = extractChatMessageParts(failureResponseText);
|
|
const failedCodexReplyMessage = {
|
|
...codexReplyMessage,
|
|
text: extractedFailureReply.strippedText,
|
|
parts: extractedFailureReply.parts,
|
|
timestamp: resolveResponseTimestamp(request.requestedAtMs),
|
|
};
|
|
|
|
this.sendToSession(
|
|
session,
|
|
{
|
|
type: 'chat:message',
|
|
payload: failedCodexReplyMessage,
|
|
},
|
|
{
|
|
skipOfflineNotification: true,
|
|
},
|
|
);
|
|
|
|
await this.persistConversationMessage(session, failedCodexReplyMessage);
|
|
await upsertChatConversationRequest(session.sessionId, {
|
|
requestId: request.requestId,
|
|
status: wasCancelled ? 'cancelled' : 'failed',
|
|
statusMessage: wasCancelled ? '요청 실행 중단' : '요청 처리 실패',
|
|
responseMessageId: failedCodexReplyMessage.id,
|
|
responseText: failedCodexReplyMessage.text,
|
|
});
|
|
}
|
|
|
|
chatRuntimeService.appendLog(
|
|
request.requestId,
|
|
wasCancelled
|
|
? '사용자 요청으로 실행이 중단되었습니다.'
|
|
: error instanceof Error
|
|
? `실행 오류: ${error.message}`
|
|
: '실행 오류가 발생했습니다.',
|
|
);
|
|
appendActivityLine(
|
|
wasCancelled
|
|
? '# 상태: 사용자 요청으로 실행이 중단되었습니다.'
|
|
: error instanceof Error
|
|
? `# 오류: ${error.message}`
|
|
: '# 오류: 실행 오류가 발생했습니다.',
|
|
);
|
|
const terminalErrorEnvelope = this.sendToSession(session, {
|
|
type: 'chat:message',
|
|
payload: createMessage(
|
|
'system',
|
|
wasCancelled ? '요청 실행이 중단되었습니다.' : '요청 처리 중 오류가 발생했습니다.',
|
|
request.requestId,
|
|
),
|
|
});
|
|
session.pendingQueueReleaseEventId = terminalErrorEnvelope.eventId;
|
|
this.emitJobState(session, {
|
|
requestId: request.requestId,
|
|
status: 'failed',
|
|
mode: request.mode,
|
|
queueSize: session.queue.length,
|
|
message: wasCancelled ? '요청 실행 중단' : '요청 처리 실패',
|
|
});
|
|
await refreshChatSessionReferenceForRequest({
|
|
sessionId: session.sessionId,
|
|
requestId: request.requestId,
|
|
context: request.context ?? session.context ?? null,
|
|
input: request.text,
|
|
requestStatus: wasCancelled ? 'cancelled' : 'failed',
|
|
requestedAt: new Date(request.requestedAtMs),
|
|
completedAt: new Date(),
|
|
});
|
|
throw error;
|
|
} finally {
|
|
stopProgressTimer();
|
|
activeChatProcessRegistry.delete(request.requestId);
|
|
if (chatRuntimeService.getJobDetail(request.requestId).terminalStatus == null) {
|
|
chatRuntimeService.finishJob(request.requestId, terminalStatus);
|
|
}
|
|
this.cancelledRequestIds.delete(request.requestId);
|
|
session.activeRequestCount = Math.max(0, session.activeRequestCount - 1);
|
|
this.tryStartNextQueuedRequest(session);
|
|
}
|
|
}
|
|
}
|