sneakoscope 4.8.6 → 5.1.2

package/dist/core/agents/agent-lifecycle.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import fsp from 'node:fs/promises';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { appendAgentLedgerEvent } from './agent-central-ledger.js';
 export const AGENT_LIFECYCLE_STATES = Object.freeze(['planned', 'launching', 'running', 'heartbeat_missing', 'collecting', 'completed', 'failed', 'timed_out', 'closing', 'closed', 'killed']);
@@ -6,10 +7,12 @@ export const AGENT_HEARTBEAT_INTERVAL_MS = 5000;
 export const AGENT_HEARTBEAT_TIMEOUT_MS = 60000;
 export const AGENT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
 const SESSION_LOCKS = new Map();
-async function withSessionLock(root, fn) {
-    const previous = SESSION_LOCKS.get(root) || Promise.resolve();
+const AGGREGATE_FLUSH_TIMERS = new Map();
+async function withSessionLock(root, sessionId, fn) {
+    const key = `${path.resolve(root)}:${sessionId || 'aggregate'}`;
+    const previous = SESSION_LOCKS.get(key) || Promise.resolve();
     const next = previous.catch(() => undefined).then(fn);
-    SESSION_LOCKS.set(root, next.catch(() => undefined));
+    SESSION_LOCKS.set(key, next.catch(() => undefined));
     return next;
 }
 export async function openAgentSession(root, agent) {
@@ -30,8 +33,7 @@ export async function closeAgentSession(root, agent, status = 'closed') {
     return updateSession(root, agent, { status, closed_at: nowIso(), heartbeat_at: nowIso() }, 'session_closed', agent.session_id);
 }
 export async function assertAllAgentSessionsClosed(root) {
-    const sessions = await readJson(path.join(root, 'agent-sessions.json'), { sessions: {} });
-    const rows = Object.values(sessions.sessions || {});
+    const rows = await readAllSessionRows(root);
     const open = rows.filter((session) => !['closed', 'blocked', 'failed', 'killed', 'timed_out'].includes(String(session.status)));
     const closed = rows.filter((session) => String(session.status) === 'closed');
     return {
@@ -55,8 +57,7 @@ export async function writeAgentLifecyclePolicy(root) {
     return policy;
 }
 export async function writeAgentLifecycleAggregate(root) {
-    const sessions = await readJson(path.join(root, 'agent-sessions.json'), { sessions: {} });
-    const rows = Object.values(sessions.sessions || {});
+    const rows = await readAllSessionRows(root);
     const aggregate = {
         schema: 'sks.agent-lifecycle-aggregate.v1',
         updated_at: nowIso(),
@@ -64,6 +65,10 @@ export async function writeAgentLifecycleAggregate(root) {
         total_sessions: rows.length,
         closed_session_count: rows.filter((session) => String(session.status) === 'closed').length
     };
+    await writeJsonAtomic(path.join(root, 'agent-sessions.json'), {
+        schema: 'sks.agent-sessions.v1',
+        sessions: Object.fromEntries(rows.map((session) => [String(session.session_key || session.session_id || session.agent_id || ''), session]))
+    });
     await writeJsonAtomic(path.join(root, 'agent-lifecycle-aggregate.json'), aggregate);
     await writeJsonAtomic(path.join(root, 'agent-lifecycle.json'), {
         schema: 'sks.agent-lifecycle.v1',
@@ -73,8 +78,8 @@ export async function writeAgentLifecycleAggregate(root) {
     return aggregate;
 }
 export async function detectStaleAgentSessions(root, now = Date.now()) {
-    const sessions = await readJson(path.join(root, 'agent-sessions.json'), { sessions: {} });
-    const stale = Object.values(sessions.sessions || {}).filter((session) => {
+    const rows = await readAllSessionRows(root);
+    const stale = rows.filter((session) => {
         if (['closed', 'blocked', 'failed', 'killed', 'timed_out'].includes(String(session.status)))
             return false;
         const heartbeat = Date.parse(String(session.heartbeat_at || session.opened_at || ''));
@@ -89,12 +94,11 @@ export function agentHardTimeoutMs(env = process.env) {
     return Math.max(1000, Math.min(raw, 24 * 60 * 60 * 1000));
 }
 export async function killTimedOutAgentSessions(root, now = Date.now(), opts = {}) {
-    return withSessionLock(root, async () => {
+    return withSessionLock(root, 'timeout-reaper', async () => {
         const hardTimeoutMs = opts.hardTimeoutMs || agentHardTimeoutMs(opts.env);
-        const file = path.join(root, 'agent-sessions.json');
-        const data = await readJson(file, { schema: 'sks.agent-sessions.v1', sessions: {} });
+        const rows = await readAllSessionRows(root);
         const killed = [];
-        for (const [sessionKey, session] of Object.entries(data.sessions || {})) {
+        for (const session of rows) {
             if (['closed', 'blocked', 'failed', 'killed', 'timed_out'].includes(String(session.status)))
                 continue;
             const opened = Date.parse(String(session.opened_at || ''));
@@ -103,8 +107,8 @@ export async function killTimedOutAgentSessions(root, now = Date.now(), opts = {
             const heartbeatTimedOut = Number.isFinite(heartbeat) && now - heartbeat > AGENT_HEARTBEAT_TIMEOUT_MS;
             if (!hardTimedOut && !heartbeatTimedOut)
                 continue;
-            const sessionId = session.session_id || sessionKey;
-            data.sessions[sessionKey] = {
+            const sessionId = session.session_id || session.session_key || session.agent_id;
+            const next = {
                 ...session,
                 status: 'killed',
                 killed_at: new Date(now).toISOString(),
@@ -112,11 +116,10 @@ export async function killTimedOutAgentSessions(root, now = Date.now(), opts = {
                 heartbeat_at: new Date(now).toISOString(),
                 kill_reason: hardTimedOut ? 'hard_timeout' : 'heartbeat_timeout'
             };
-            await writeSessionRecord(root, data.sessions[sessionKey]);
-            await appendAgentLedgerEvent(root, { agent_id: String(session.agent_id || sessionKey), session_id: sessionId, event_type: 'session_killed_timeout', payload: { kill_reason: data.sessions[sessionKey].kill_reason } });
+            await writeSessionRecord(root, next);
+            await appendAgentLedgerEvent(root, { agent_id: String(session.agent_id || sessionId), session_id: sessionId, event_type: 'session_killed_timeout', payload: { kill_reason: next.kill_reason } });
             killed.push(sessionId);
         }
-        await writeJsonAtomic(file, data);
         await writeAgentLifecycleAggregate(root);
         const report = {
             schema: 'sks.agent-timeout-kill-report.v1',
@@ -130,40 +133,88 @@ export async function killTimedOutAgentSessions(root, now = Date.now(), opts = {
     });
 }
 async function updateSession(root, agent, patch, eventType, sessionId) {
-    return withSessionLock(root, async () => {
-        const file = path.join(root, 'agent-sessions.json');
-        const data = await readJson(file, { schema: 'sks.agent-sessions.v1', sessions: {} });
-        data.sessions = data.sessions || {};
-        const agentId = String(agent.id || agent.agent_id || sessionId);
-        const sessionKey = String(agent.session_generation_id || agent.session_id || agentId);
-        data.sessions[sessionKey] = {
-            ...(data.sessions[sessionKey] || {
+    const agentId = String(agent.id || agent.agent_id || sessionId);
+    const sessionKey = String(agent.session_generation_id || agent.session_id || agentId);
+    return withSessionLock(root, sessionKey, async () => {
+        const current = await readSessionRow(root, sessionKey);
+        const next = {
+            ...(current || {
                 agent_id: agentId,
                 slot_id: agent.slot_id || agent.worker_slot_id || null,
                 generation_index: Number.isFinite(Number(agent.generation_index)) ? Number(agent.generation_index) : null,
                 session_artifact_dir: agent.session_artifact_dir || null,
-                session_id: sessionId
+                session_id: sessionId,
+                session_key: sessionKey
             }),
             agent_id: agentId,
-            slot_id: agent.slot_id || agent.worker_slot_id || data.sessions[sessionKey]?.slot_id || null,
-            generation_index: Number.isFinite(Number(agent.generation_index)) ? Number(agent.generation_index) : data.sessions[sessionKey]?.generation_index ?? null,
-            session_artifact_dir: agent.session_artifact_dir || data.sessions[sessionKey]?.session_artifact_dir || null,
+            slot_id: agent.slot_id || agent.worker_slot_id || current?.slot_id || null,
+            generation_index: Number.isFinite(Number(agent.generation_index)) ? Number(agent.generation_index) : current?.generation_index ?? null,
+            session_artifact_dir: agent.session_artifact_dir || current?.session_artifact_dir || null,
             session_id: sessionId,
+            session_key: sessionKey,
             ...patch
         };
-        await writeJsonAtomic(file, data);
-        await writeSessionRecord(root, data.sessions[sessionKey]);
-        await writeAgentLifecycleAggregate(root);
+        await writeSessionRecord(root, next);
+        if (eventType === 'heartbeat')
+            scheduleAgentLifecycleAggregate(root);
+        else
+            await writeAgentLifecycleAggregate(root);
         await appendAgentLedgerEvent(root, { agent_id: agentId, session_id: sessionId, event_type: eventType, payload: patch });
-        return data.sessions[sessionKey];
+        return next;
     });
 }
 async function writeSessionRecord(root, session) {
+    const sessionKey = sanitizeSessionFileName(session.session_key || session.session_id || session.agent_id || 'session');
+    await writeJsonAtomic(path.join(sessionShardDir(root), `${sessionKey}.json`), { schema: 'sks.agent-session-record.v1', ...session, session_key: sessionKey });
     const artifactDir = session.session_artifact_dir;
     if (artifactDir) {
         await writeJsonAtomic(path.join(root, artifactDir, 'agent-session-record.json'), { schema: 'sks.agent-session-record.v1', ...session });
         return;
     }
-    await writeJsonAtomic(path.join(root, 'sessions', String(session.agent_id || session.session_id) + '.json'), { schema: 'sks.agent-session-record.v1', ...session });
+}
+async function readSessionRow(root, sessionKey) {
+    const shard = await readJson(path.join(sessionShardDir(root), `${sanitizeSessionFileName(sessionKey)}.json`), null).catch(() => null);
+    if (shard)
+        return shard;
+    const aggregate = await readJson(path.join(root, 'agent-sessions.json'), { sessions: {} }).catch(() => ({ sessions: {} }));
+    const sessions = Array.isArray(aggregate?.sessions)
+        ? Object.fromEntries(aggregate.sessions.map((row) => [String(row.session_key || row.session_id || row.agent_id || ''), row]))
+        : aggregate?.sessions || {};
+    return sessions[sessionKey] || null;
+}
+async function readAllSessionRows(root) {
+    const rows = [];
+    const dir = sessionShardDir(root);
+    const names = await fsp.readdir(dir).catch(() => []);
+    for (const name of names.sort()) {
+        if (!name.endsWith('.json'))
+            continue;
+        const row = await readJson(path.join(dir, name), null).catch(() => null);
+        if (row && row.schema === 'sks.agent-session-record.v1')
+            rows.push(row);
+    }
+    if (rows.length)
+        return rows;
+    const aggregate = await readJson(path.join(root, 'agent-sessions.json'), { sessions: {} }).catch(() => ({ sessions: {} }));
+    if (Array.isArray(aggregate?.sessions))
+        return aggregate.sessions;
+    return Object.values(aggregate?.sessions || {});
+}
+function scheduleAgentLifecycleAggregate(root) {
+    const key = path.resolve(root);
+    if (AGGREGATE_FLUSH_TIMERS.has(key))
+        return;
+    const timer = setTimeout(() => {
+        AGGREGATE_FLUSH_TIMERS.delete(key);
+        writeAgentLifecycleAggregate(root).catch(() => undefined);
+    }, 5000);
+    timer.unref?.();
+    AGGREGATE_FLUSH_TIMERS.set(key, timer);
+}
+function sessionShardDir(root) {
+    return path.join(root, 'sessions');
+}
+function sanitizeSessionFileName(value) {
+    return String(value || 'session').replace(/[^A-Za-z0-9._-]+/g, '_');
 }
 //# sourceMappingURL=agent-lifecycle.js.map