@supen-ai/cli 1.4.8 → 1.4.9

package/daemon/dist/http/routes/system.js

@@ -6,7 +6,7 @@ import { createRequire } from 'module';
 import { spawn, spawnSync } from 'child_process';
 import { DAEMON_HOSTNAME, DEFAULT_MODEL, MODELS_REGISTRY, SUPEN_HOME, reloadModelsRegistry, } from '../../core/config.js';
 import { readConfigSummary, readConfigYamlFile, writeConfigYamlFile, } from '../../core/env.js';
-import { readSpaceEnvMap, updateSpaceEnvMap, withRuntimeSpaceEnv, withSupenLlmEnv } from '../../core/space-env.js';
+import { readSpaceEnvMap, updateSpaceEnvMap, withSupenLlmEnv } from '../../core/space-env.js';
 import { readCodexSubscription } from '../../core/codex-subscription.js';
 import { buildHubSnapshotForSpace } from '../../core/hub-snapshot.js';
 import { readEnrollmentState, createEnrollmentToken, verifyEnrollmentToken, setTrustState } from '../../core/enrollment.js';
@@ -22,10 +22,10 @@ import { getMcpManager } from '../../mcp/index.js';
 import { logger } from '../../core/logger.js';
 import { buildDaemonOpenApiSpec } from '../../channels/http-routes.js';
 import { writeJson, writeProtocolError, readJsonBody } from '../response.js';
-import { listRecentThreadEventsAfter, readThreadEventLogHead, } from '../../core/thread-event-log.js';
+import { appendThreadEvent, listRecentThreadEventsAfter, readThreadEventLogHead, } from '../../core/thread-event-log.js';
 import { projectThreadRuntimeState } from '../../core/thread-runtime-state.js';
 import { attachThreadContextToChunk, readThreadContext, } from '../../core/thread-context.js';
-import { addThreadStreamClient, removeThreadStreamClient, writeThreadStreamEvent } from '../thread-stream.js';
+import { addThreadStreamClient, broadcastToThread, removeThreadStreamClient, writeThreadStreamEvent } from '../thread-stream.js';
 const DEFAULT_TOKEN_TTL_MINUTES = 20;
 const SPACE_LOG_EVENT_LIMIT = 200;
 const SPACE_LOG_STREAM_POLL_MS = 1000;
@@ -882,141 +882,6 @@ function readThreadWorkspacePath(filePath) {
     }
     return null;
 }
-const CODEX_THREAD_OBSERVER_STDOUT_MAX_BYTES = 4 * 1024 * 1024;
-function startCodexThreadObserver(input) {
-    const codexPath = resolveCliExecutablePath('codex');
-    if (!codexPath) {
-        input.write({
-            type: 'error',
-            message: 'codex executable was not found in the daemon tool lookup PATH',
-        });
-        return () => { };
-    }
-    const child = spawn(codexPath, ['app-server', '--listen', 'stdio://'], {
-        cwd: input.cwd,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: withRuntimeSpaceEnv(buildToolLookupEnv()),
-    });
-    let buffer = '';
-    let nextId = 1;
-    let observerEventIndex = 0;
-    let initialized = false;
-    let closed = false;
-    child.on('error', (err) => {
-        if (closed)
-            return;
-        input.write({
-            type: 'error',
-            message: err instanceof Error ? err.message : String(err),
-        });
-    });
-    child.on('close', () => {
-        closed = true;
-    });
-    child.stdin.on('error', (error) => {
-        closed = true;
-        if (error?.code === 'EPIPE' || error?.code === 'ECONNRESET')
-            return;
-        logger.debug({ err: error, threadId: input.threadId }, 'Codex thread observer stdin failed');
-    });
-    const closeObserver = (signal = 'SIGTERM') => {
-        if (closed)
-            return;
-        closed = true;
-        try {
-            child.stdin.destroy();
-            child.kill(signal);
-        }
-        catch {
-            // Observer cleanup is best-effort; the HTTP stream is already closing.
-        }
-    };
-    const send = (message) => {
-        if (closed || child.stdin.destroyed || !child.stdin.writable)
-            return;
-        try {
-            child.stdin.write(`${JSON.stringify(message)}\n`);
-        }
-        catch (error) {
-            closed = true;
-            const code = error?.code;
-            if (code === 'EPIPE' || code === 'ECONNRESET')
-                return;
-            logger.debug({ err: error, threadId: input.threadId }, 'Codex thread observer write failed');
-        }
-    };
-    const request = (method, params) => {
-        send({ id: nextId++, method, ...(params ? { params } : {}) });
-    };
-    child.stdout.on('data', (chunk) => {
-        if (closed)
-            return;
-        buffer += String(chunk);
-        if (buffer.length > CODEX_THREAD_OBSERVER_STDOUT_MAX_BYTES) {
-            logger.debug({ threadId: input.threadId, bytes: buffer.length }, 'Codex thread observer stdout exceeded line buffer limit');
-            closeObserver('SIGKILL');
-            return;
-        }
-        while (true) {
-            const newlineIndex = buffer.indexOf('\n');
-            if (newlineIndex < 0)
-                break;
-            const line = buffer.slice(0, newlineIndex).trim();
-            buffer = buffer.slice(newlineIndex + 1);
-            if (!line.startsWith('{'))
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (parsed.id !== undefined && typeof parsed.method === 'string') {
-                send({ id: parsed.id, result: {} });
-                continue;
-            }
-            if (parsed.id !== undefined) {
-                if (!initialized && parsed.id === 1) {
-                    initialized = true;
-                    send({ method: 'initialized' });
-                    request('thread/resume', {
-                        threadId: input.threadId,
-                        cwd: input.cwd,
-                        experimentalRawEvents: true,
-                    });
-                }
-                continue;
-            }
-            const method = typeof parsed.method === 'string' ? parsed.method : '';
-            if (!method)
-                continue;
-            const params = parsed.params && typeof parsed.params === 'object'
-                ? parsed.params
-                : {};
-            const eventThreadId = typeof params.threadId === 'string' ? params.threadId : '';
-            if (eventThreadId !== input.threadId)
-                continue;
-            observerEventIndex += 1;
-            input.write(codexAppServerEventChunk(method, params), `observer-${Date.now()}-${observerEventIndex}`);
-        }
-    });
-    child.stderr.on('data', () => { });
-    child.once('error', (error) => {
-        logger.debug({ err: error, threadId: input.threadId }, 'Codex thread observer failed');
-    });
-    request('initialize', {
-        clientInfo: {
-            name: 'supen-daemon-thread-observer',
-            title: 'Supen',
-            version: '0.1.0',
-        },
-        capabilities: { experimentalApi: true },
-    });
-    return () => {
-        closeObserver();
-    };
-}
 function normalizeThreadStatusToken(value) {
     return typeof value === 'string'
         ? value.trim().toLowerCase().replace(/[-_\s]/g, '')
@@ -1465,6 +1330,23 @@ function isMirroredGoalContextMessage(text) {
     const trimmed = text.trim();
     return trimmed.startsWith('<goal_context>') && trimmed.endsWith('</goal_context>');
 }
+function threadGoalEventAction(event) {
+    const raw = event.raw_payload && typeof event.raw_payload === 'object'
+        ? event.raw_payload
+        : {};
+    const method = typeof raw.method === 'string' ? raw.method : '';
+    const params = raw.params && typeof raw.params === 'object' ? raw.params : {};
+    if (method === 'thread/goal/cleared')
+        return 'cleared';
+    if (method !== 'thread/goal/updated')
+        return null;
+    const status = typeof params.status === 'string' ? params.status.trim().toLowerCase() : '';
+    if (status === 'paused')
+        return 'paused';
+    if (status === 'active' || status === 'resumed')
+        return 'active';
+    return null;
+}
 function mirroredThreadWorkspacePath(threadPath, stateEntry) {
     const stateCwd = typeof stateEntry?.cwd === 'string' ? stateEntry.cwd : null;
     const threadWorkspace = readThreadWorkspacePath(threadPath);
@@ -1737,6 +1619,22 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
             chunk,
         });
     }
+    for (const event of usableEventLogEvents) {
+        const action = threadGoalEventAction(event);
+        if (!action)
+            continue;
+        const eventTimestampMs = Date.parse(event.received_at);
+        const goalTimestampMs = recentGoalContext ? Date.parse(recentGoalContext.timestamp) : 0;
+        if (recentGoalContext && Number.isFinite(eventTimestampMs) && Number.isFinite(goalTimestampMs) && eventTimestampMs < goalTimestampMs) {
+            continue;
+        }
+        if (action === 'cleared') {
+            recentGoalContext = null;
+        }
+        else if (recentGoalContext) {
+            recentGoalContext = { ...recentGoalContext, status: action };
+        }
+    }
     const collapsedMessages = collapseCompletedAssistantProgressMessages(messages);
     const slicedMessages = collapsedMessages.slice(-safeLimit);
     const slicedEvents = events.slice(-safeLimit * 8);
@@ -3202,7 +3100,6 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         const workspacePath = readThreadWorkspacePath(threadPath) || process.cwd();
         const withThreadContext = (chunk) => attachThreadContextToChunk(chunk, readThreadContext({ threadId, workspace: workspacePath }));
         let streamClosed = false;
-        let stopCodexObserver = () => { };
         let pingTimer = null;
         let jsonlPollTimer = null;
         const cleanup = () => {
@@ -3213,22 +3110,8 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
                 clearInterval(pingTimer);
             if (jsonlPollTimer)
                 clearInterval(jsonlPollTimer);
-            stopCodexObserver();
             removeThreadStreamClient(threadId, res);
         };
-        stopCodexObserver = process.env.NODE_ENV === 'test'
-            ? () => { }
-            : startCodexThreadObserver({
-                threadId,
-                cwd: workspacePath,
-                write: (chunk, id) => {
-                    if (streamClosed)
-                        return;
-                    const wrote = writeThreadStreamEvent(res, withThreadContext(chunk), id ? { id } : {});
-                    if (!wrote)
-                        cleanup();
-                },
-            });
         pingTimer = setInterval(() => {
             if (!writeSse(res)) {
                 cleanup();
@@ -3323,6 +3206,52 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         writeJson(res, 200, { thread: serializeAdoptedMirroredThread(thread) });
         return true;
     }
+    const mirroredThreadGoalMatch = codexThreadActionRoute(pathname, 'goal');
+    if (mirroredThreadGoalMatch && (method === 'PATCH' || method === 'DELETE')) {
+        const threadId = decodeURIComponent(mirroredThreadGoalMatch[1] || '').trim();
+        if (!threadId || !codexThreadFiles().has(threadId)) {
+            writeProtocolError(res, 404, 'not_found', 'mirrored_thread_not_found', 'Mirrored task history was not found.');
+            return true;
+        }
+        let status = null;
+        if (method === 'PATCH') {
+            const parsed = await readJsonBody(req);
+            const rawStatus = parsed && typeof parsed === 'object' && typeof parsed.status === 'string'
+                ? String(parsed.status).trim().toLowerCase()
+                : '';
+            if (rawStatus === 'active' || rawStatus === 'resumed')
+                status = 'active';
+            if (rawStatus === 'paused')
+                status = 'paused';
+            if (!status) {
+                writeProtocolError(res, 400, 'validation_error', 'invalid_goal_status', 'Expected goal status "active" or "paused".');
+                return true;
+            }
+        }
+        const now = new Date().toISOString();
+        const rawPayload = method === 'DELETE'
+            ? { method: 'thread/goal/cleared', params: { threadId, source: 'supen', timestamp: now } }
+            : { method: 'thread/goal/updated', params: { threadId, status, source: 'supen', timestamp: now } };
+        const event = appendThreadEvent({
+            threadId,
+            runtimeThreadId: threadId,
+            source: 'web',
+            eventType: method === 'DELETE' ? 'thread_goal_cleared' : 'thread_goal_updated',
+            rawPayload,
+            receivedAt: now,
+        });
+        const chunk = threadStreamChunkForEvent(event);
+        if (chunk) {
+            broadcastToThread(threadId, attachThreadContextToChunk(chunk, readThreadContext({ threadId })), { id: event.sequence });
+        }
+        writeJson(res, 200, {
+            ok: true,
+            thread_id: threadId,
+            goal: method === 'DELETE' ? null : { status },
+            event_log_head: event.sequence,
+        });
+        return true;
+    }
     if (codexProjectsOpenRoute(pathname) && method === 'POST') {
         try {
             const parsed = await readJsonBody(req);