@supen-ai/cli 1.4.0 → 1.4.2

package/daemon/dist/index.js

@@ -4,7 +4,7 @@ import { CODEX_TRUSTED_DATA_HOSTS, ASSISTANT_NAME, SUPEN_HOME, POLL_INTERVAL, TR
 import './channels/index.js';
 import { SkillHub } from './skills/hub.js';
 import { getChannelFactory, getRegisteredChannelNames, } from './channels/registry.js';
-import { ensureSession, getAllChats, getAllRegisteredProjects, getAllSessions, getMessagesSince, getNewMessages, getRouterState, getSessionForAgent, initStore, cleanupStaleSessions, cleanupStaleAutomationExecutions, touchAutomationRun, updateSessionStatus, setRegisteredProject, setRouterState, storeChatMetadata, storeMessage, storeSessionUiEvent, resolveFromChatJid, } from './core/store.js';
+import { ensureThread, getAllChats, getAllRegisteredProjects, getAllThreads, getMessagesSince, getNewMessages, getRouterState, getThreadForAgent, initStore, cleanupStaleThreads, cleanupStaleAutomationExecutions, touchAutomationRun, updateThreadStatus, setRegisteredProject, setRouterState, storeChatMetadata, storeMessage, storeThreadUiEvent, resolveFromChatJid, } from './core/store.js';
 import { logger } from './core/logger.js';
 import { readEnrollmentState, verifyEnrollmentToken, } from './core/enrollment.js';
 import { routeOutbound, routeOutboundFile, routeSetTyping, routeEditMessage, } from './router.js';
@@ -23,6 +23,7 @@ import { listCommands, resolveCommandInput } from './commands/catalog.js';
 import { findLatestInterruptIndex, trimMessagesAfterInterrupt, } from './core/interrupts.js';
 import { isSupabaseConfigured, pullFromSupabase, scheduleSupabasePush, startPeriodicSupabasePush, } from './sync/supabase-sync.js';
 import { appendStreamChunk, createStreamState, } from './core/streaming.js';
+import { attachThreadContextToChunk, readThreadContext, } from './core/thread-context.js';
 const DEFAULT_AUTOMATION_TASK_TIMEOUT_MS = 12 * 60 * 1000;
 function automationTaskTimeoutMs() {
     const raw = process.env.SUPEN_AUTOMATION_TASK_TIMEOUT_MS;
@@ -33,40 +34,23 @@ function automationTaskTimeoutMs() {
         return DEFAULT_AUTOMATION_TASK_TIMEOUT_MS;
     return parsed;
 }
-import { appendThreadEvent } from './core/thread-event-log.js';
 import { parseProgressEvent, formatProgressText, progressKeyFromEvent } from './core/progress.js';
 import { buildAssistantOutputExcerpt, buildObservableToolDetail, buildProgressDetail, buildTaskContextExcerpt, canonicalAutomationLogFields, classifyObservableLogEvent, excerptText, } from './core/observable-logging.js';
 // Global state
 let registeredProjects = {};
-const sessions = {}; // folder -> sessionId
+const threads = {}; // folder -> threadId
 const lastAgentTimestamp = {}; // chatJid -> iso
 const channels = [];
 const activeDaemons = new Map();
 export function captureCodexStreamPayload(input) {
-    let sequence;
+    let payload = input.payload;
     try {
-        const event = appendThreadEvent({
-            threadId: input.threadId,
-            runtimeThreadId: input.runtimeThreadId || input.threadId,
-            source: 'codex-app-server',
-            eventType: typeof input.payload.type === 'string'
-                ? input.payload.type
-                : typeof input.payload.method === 'string'
-                    ? input.payload.method
-                    : 'codex-event',
-            rawPayload: input.payload,
-        });
-        sequence = event.sequence;
+        payload = attachThreadContextToChunk(input.payload, readThreadContext({ threadId: input.threadId }));
     }
     catch (error) {
-        logger.warn({
-            err: error,
-            agentId: input.agentId,
-            threadId: input.threadId,
-            runtimeThreadId: input.runtimeThreadId || input.threadId,
-        }, 'Failed to capture Codex stream payload');
+        logger.debug({ err: error, agentId: input.agentId, threadId: input.threadId }, 'Skipped Codex stream context attachment');
     }
-    broadcastToThread(input.threadId, input.payload, sequence === undefined ? {} : { id: sequence });
+    broadcastToThread(input.threadId, payload);
 }
 function appServerChunk(method, params = {}) {
     return {
@@ -124,24 +108,24 @@ const activeAgentLocks = new Map();
 // Pending-run flags: if a second message arrives while the lock is held,
 // set the flag so the run drains immediately after the current one finishes.
 const pendingRuns = new Set();
-function requestSessionStop(agentId, sessionId, actor = 'unknown') {
-    const session = getSessionForAgent(agentId, sessionId);
-    const chatJid = session?.source_ref?.trim() || `web:${agentId}:${sessionId}`;
+function requestThreadStop(agentId, threadId, actor = 'unknown') {
+    const thread = getThreadForAgent(agentId, threadId);
+    const chatJid = thread?.source_ref?.trim() || `web:${agentId}:${threadId}`;
     const daemon = activeDaemons.get(chatJid);
     if (!daemon) {
         return {
             ok: false,
-            code: 'session_not_running',
-            message: `Task "${sessionId}" is not currently running.`,
+            code: 'thread_not_running',
+            message: `Task "${threadId}" is not currently running.`,
             chatJid,
         };
     }
-    logger.info({ agentId, sessionId, chatJid, actor }, 'Stop requested for active session');
+    logger.info({ agentId, threadId, chatJid, actor }, 'Stop requested for active thread');
     daemon.interrupt();
     return {
         ok: true,
         code: 'stop_requested',
-        message: `Stop requested for session "${sessionId}".`,
+        message: `Stop requested for thread "${threadId}".`,
         chatJid,
     };
 }
@@ -195,7 +179,7 @@ async function runAndDrain(chatJid) {
         }
     }
 }
-export function resolveSessionChannel(chatJid, existingChannel) {
+export function resolveThreadChannel(chatJid, existingChannel) {
     if (chatJid.startsWith('dc:'))
         return 'discord';
     if (chatJid.startsWith('web:'))
@@ -211,14 +195,14 @@ export function resolveSessionChannel(chatJid, existingChannel) {
     }
     return existingChannel || chatJid.split(':')[0] || 'unknown';
 }
-export function resolveStoredSessionChannel(chatJid) {
+export function resolveStoredThreadChannel(chatJid) {
     const resolved = resolveFromChatJid(chatJid);
     if (!resolved)
         return undefined;
-    return getSessionForAgent(resolved.agentId, resolved.sessionId)?.channel;
+    return getThreadForAgent(resolved.agentId, resolved.threadId)?.channel;
 }
 export function resolveRoutingChannel(chatJid) {
-    return resolveSessionChannel(chatJid, resolveStoredSessionChannel(chatJid));
+    return resolveThreadChannel(chatJid, resolveStoredThreadChannel(chatJid));
 }
 async function processMessages(chatJid) {
     let group = registeredProjects[chatJid];
@@ -233,32 +217,32 @@ async function processMessages(chatJid) {
             isMain: false,
         };
     }
-    // Resolve or create a session for this chat so directories exist.
-    // IMPORTANT: always resolve agentId + sessionId from the JID — never use
-    // chatJid itself as session_id, or the full JID gets stored and re-prefixed
+    // Resolve or create a thread for this chat so directories exist.
+    // IMPORTANT: always resolve agentId + threadId from the JID — never use
+    // chatJid itself as thread_id, or the full JID gets stored and re-prefixed
     // on every subsequent call, making the key grow indefinitely.
     let agentId = group.agent_id || group.folder;
-    let sessionId;
+    let threadId;
     const resolved = resolveFromChatJid(chatJid);
     if (resolved) {
         agentId = resolved.agentId;
-        sessionId = resolved.sessionId;
+        threadId = resolved.threadId;
     }
     else {
         // Fallback for unrecognised JID formats: split on ':' and use last segment
         const parts = chatJid.split(':');
-        sessionId = parts.length >= 2 ? parts.slice(1).join(':') : chatJid;
+        threadId = parts.length >= 2 ? parts.slice(1).join(':') : chatJid;
         if (agentId === 'unknown' && parts.length >= 2) {
             agentId = parts[1];
         }
     }
-    const existingSession = getSessionForAgent(agentId, sessionId);
-    const channel = existingSession
-        ? resolveSessionChannel(chatJid, existingSession.channel)
+    const existingThread = getThreadForAgent(agentId, threadId);
+    const channel = existingThread
+        ? resolveThreadChannel(chatJid, existingThread.channel)
         : resolveRoutingChannel(chatJid);
-    const session = ensureSession({
+    const thread = ensureThread({
         agent_id: agentId,
-        session_id: sessionId,
+        thread_id: threadId,
         channel,
         agent_name: group.name,
         source_ref: chatJid,
@@ -354,7 +338,7 @@ async function processMessages(chatJid) {
             const portableBuiltinReply = await executePortableBuiltinCommand(resolvedSlashCommand.text, {
                 channel: routingChannel,
                 agentId,
-                sessionId,
+                threadId,
                 actor: latestMsg?.sender || chatJid,
                 isAdmin: isAdminActor(latestMsg?.sender || chatJid),
             });
@@ -375,7 +359,7 @@ async function processMessages(chatJid) {
         }
         // Check if we have a valid workspace for this group
         // (group is guaranteed to be set now because of our fallback logic at the top)
-        const workspace = session.task_workspace_folder || getFactoryPath(group);
+        const workspace = thread.task_workspace_folder || getFactoryPath(group);
         const hasWorkspace = fs.existsSync(workspace);
         logger.info({ chatJid, workspace, hasWorkspace }, 'processMessages: workspace check');
         const automationMessage = [...runnableMessages]
@@ -571,16 +555,16 @@ async function processMessages(chatJid) {
                 latestMsg?.id ||
                 taskId;
             const streamState = createStreamState(`${chatJid}:${turnId}`);
-            const isAdoptedCodexAppServerSession = chatJid.startsWith('web:') && session.backend_driver_id === 'codex-app-server';
-            const mirroredThreadId = isAdoptedCodexAppServerSession ? session.session_id : taskId;
-            const shouldMirrorTaskThread = Boolean(mirroredThreadId) && (chatJid.startsWith('task:') || isAdoptedCodexAppServerSession);
+            const isAdoptedCodexAppServerThread = chatJid.startsWith('web:') && thread.backend_driver_id === 'codex-app-server';
+            const mirroredThreadId = isAdoptedCodexAppServerThread ? thread.thread_id : taskId;
+            const shouldMirrorTaskThread = Boolean(mirroredThreadId) && (chatJid.startsWith('task:') || isAdoptedCodexAppServerThread);
             const mirrorTaskThreadChunk = (payload) => {
                 if (!shouldMirrorTaskThread)
                     return;
                 captureCodexStreamPayload({
                     agentId,
                     threadId: mirroredThreadId,
-                    runtimeThreadId: session.session_id,
+                    runtimeThreadId: thread.thread_id,
                     payload,
                 });
             };
@@ -683,7 +667,7 @@ async function processMessages(chatJid) {
                 try {
                     await completeAutomationRun({
                         sendMessage: (jid, notification) => sendFn(jid, notification),
-                        ensureNotificationSessionExists,
+                        ensureNotificationThreadExists,
                     }, automationMessage, chatJid, outcome, detail);
                 }
                 catch (completeError) {
@@ -697,7 +681,7 @@ async function processMessages(chatJid) {
                 if (useGatewayChannelReplyLifecycle) {
                     await ensureChannelReplyHandle('Thinking...');
                 }
-                // Get MCP manager for this session
+                // Get MCP manager for this thread
                 let mcpManager;
                 try {
                     mcpManager = await getMcpManager();
@@ -705,7 +689,7 @@ async function processMessages(chatJid) {
                 catch (err) {
                     logger.warn({ err }, 'Failed to get MCP manager, continuing without MCP');
                 }
-                const daemon = new AgentCortex(agentId, { ...session, task_id: taskId }.session_id, {
+                const daemon = new AgentCortex(agentId, { ...thread, task_id: taskId }.thread_id, {
                     mcpManager,
                     onStateChange: async (state) => {
                         const eventData = {
@@ -726,7 +710,7 @@ async function processMessages(chatJid) {
                                         ? 'idle'
                                         : 'active';
                             mirrorTaskThreadChunk(appServerChunk('thread/status/changed', {
-                                threadId: session.session_id,
+                                threadId: thread.thread_id,
                                 status: { type: statusType },
                             }));
                         }
@@ -826,11 +810,11 @@ async function processMessages(chatJid) {
                                 id: streamState.streamId,
                             });
                             mirrorTaskThreadChunk(appServerChunk('turn/completed', {
-                                threadId: session.session_id,
+                                threadId: thread.thread_id,
                                 turnId,
                                 turn: { id: turnId, status: 'completed' },
                             }));
-                            updateSessionStatus(agentId, sessionId, 'idle');
+                            updateThreadStatus(agentId, threadId, 'idle');
                         }
                         // Finalize streaming: emit stream_end so consumers
                         // know the streaming phase is complete.
@@ -972,12 +956,12 @@ async function processMessages(chatJid) {
                                 id: streamState.streamId,
                             });
                             mirrorTaskThreadChunk(appServerChunk('turn/failed', {
-                                threadId: session.session_id,
+                                threadId: thread.thread_id,
                                 turnId,
                                 turn: { id: turnId, status: 'failed' },
                                 error: { message: error?.message || text },
                             }));
-                            updateSessionStatus(agentId, sessionId, 'error');
+                            updateThreadStatus(agentId, threadId, 'error');
                         }
                         if (!isAutomationMessage && chatJid.startsWith('web:') && streamState.nextSeq > 1) {
                             broadcastToChat(chatJid, {
@@ -1026,13 +1010,13 @@ async function processMessages(chatJid) {
                 activeDaemons.set(chatJid, daemon);
                 try {
                     if (shouldMirrorTaskThread) {
-                        updateSessionStatus(agentId, sessionId, 'running');
+                        updateThreadStatus(agentId, threadId, 'running');
                         mirrorTaskThreadChunk({
                             type: 'start',
                             messageId: streamState.streamId,
                         });
                         mirrorTaskThreadChunk(appServerChunk('turn/started', {
-                            threadId: session.session_id,
+                            threadId: thread.thread_id,
                             turnId,
                             turn: { id: turnId, status: 'running' },
                         }));
@@ -1112,8 +1096,8 @@ async function processMessages(chatJid) {
                                     const parsedPayload = JSON.parse(payload);
                                     captureCodexStreamPayload({
                                         agentId,
-                                        threadId: sessionId,
-                                        runtimeThreadId: session.session_id,
+                                        threadId: threadId,
+                                        runtimeThreadId: thread.thread_id,
                                         payload: parsedPayload,
                                     });
                                     broadcastToChat(chatJid, parsedPayload);
@@ -1131,8 +1115,8 @@ async function processMessages(chatJid) {
                                     const parsedPayload = JSON.parse(payload);
                                     captureCodexStreamPayload({
                                         agentId,
-                                        threadId: sessionId,
-                                        runtimeThreadId: session.session_id,
+                                        threadId: threadId,
+                                        runtimeThreadId: thread.thread_id,
                                         payload: parsedPayload,
                                     });
                                     broadcastToChat(chatJid, parsedPayload);
@@ -1145,7 +1129,7 @@ async function processMessages(chatJid) {
                         // Mark stream dispatch completion after all chunks are broadcast to
                         // active web clients. `/chat` waits on this marker before closing
                         // the SSE response to avoid cutting off trailing streamed chunks.
-                        storeSessionUiEvent(agentId, sessionId, {
+                        storeThreadUiEvent(agentId, threadId, {
                             id: `${taskId}:stream-dispatched:${Date.now()}`,
                             timestamp: new Date().toISOString(),
                             task_id: taskId,
@@ -1300,11 +1284,11 @@ function loadState() {
         registeredProjects[jid] = group;
     }
     logger.info({ count: Object.keys(registeredProjects).length }, 'Groups loaded');
-    const dbSessions = getAllSessions();
-    for (const sess of dbSessions) {
-        sessions[sess.agent_id] = sess.session_id;
+    const dbThreads = getAllThreads();
+    for (const sess of dbThreads) {
+        threads[sess.agent_id] = sess.thread_id;
     }
-    logger.info({ count: Object.keys(sessions).length }, 'Sessions loaded');
+    logger.info({ count: Object.keys(threads).length }, 'Threads loaded');
     for (const jid of Object.keys(registeredProjects)) {
         const timestamp = getRouterState(jid);
         if (timestamp) {
@@ -1327,13 +1311,13 @@ function recoverPendingMessages() {
 }
 let sendFn;
 let createChannelFn;
-function ensureNotificationSessionExists(targetJid, fallbackAgentId) {
+function ensureNotificationThreadExists(targetJid, fallbackAgentId) {
     const resolved = resolveFromChatJid(targetJid);
     if (!resolved)
         return;
-    ensureSession({
+    ensureThread({
         agent_id: resolved.agentId || fallbackAgentId || 'unknown',
-        session_id: resolved.sessionId,
+        thread_id: resolved.threadId,
         channel: targetJid.startsWith('web:') ? 'http' : targetJid.split(':')[0] || 'unknown',
         source_ref: targetJid,
     });
@@ -1348,18 +1332,18 @@ async function main() {
     const productName = process.env.SUPEN_PRODUCT_NAME || 'Supen';
     logger.info(`${productName} Daemon starting`);
     initStore();
-    cleanupStaleSessions();
+    cleanupStaleThreads();
     cleanupStaleAutomationExecutions();
     logger.info('Database initialized');
-    // Ensure default agent and session exist
-    ensureSession({
+    // Ensure default agent and thread exist
+    ensureThread({
         agent_id: 'supen-agent',
-        session_id: 'supen-session',
+        thread_id: 'supen-thread',
         channel: 'web',
         agent_name: 'Supen Agent',
         space_id: process.env.SUPEN_SPACE_ID || 'local',
     });
-    logger.info('Default agent and session ensured');
+    logger.info('Default agent and thread ensured');
     if (isSupabaseConfigured()) {
         await pullFromSupabase();
         startPeriodicSupabasePush();
@@ -1400,7 +1384,7 @@ async function main() {
                 });
             }
         },
-        onSessionStop: (agentId, sessionId, actor) => requestSessionStop(agentId, sessionId, actor),
+        onThreadStop: (agentId, threadId, actor) => requestThreadStop(agentId, threadId, actor),
         onChatMetadata: (chatJid, timestamp, name, channel, isGroup) => handleChatMetadata(chatJid, timestamp, name, channel, isGroup),
         registeredProjects: () => registeredProjects,
         onGroupRegistered: (jid, group) => registerProject(jid, group),
@@ -1463,8 +1447,8 @@ async function main() {
     sendFn = async (jid, text, options) => {
         const messageId = options?.message_id || `bot-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
         if (!jid.startsWith('task:')) {
-            // Check if this is a gateway session - use gateway's routing which handles both
-            // regular gateway sessions and channel-based sessions (via sendReplyForChat)
+            // Check if this is a gateway thread - use gateway's routing which handles both
+            // regular gateway threads and channel-based threads (via sendReplyForChat)
             const gw = getGatewayInstance();
             if (jid.startsWith('gateway:') && gw) {
                 await gw.sendReplyForChat(jid, text, options?.message_id, options?.trace_id);