@steadwing/openalerts 0.2.4 → 0.2.5

package/dist/collections/event-parser.js

@@ -0,0 +1,321 @@
+export function sessionInfoToMonitor(info) {
+    return {
+        key: info.key,
+        agentId: info.agentId,
+        lastActivityAt: info.lastActivityAt,
+        status: "idle",
+        spawnedBy: info.spawnedBy,
+        messageCount: info.messageCount,
+    };
+}
+// ─── Chat Event Parser ───────────────────────────────────────────────────────
+export function chatEventToAction(event) {
+    let type = "streaming";
+    if (event.state === "final")
+        type = "complete";
+    else if (event.state === "delta")
+        type = "streaming";
+    else if (event.state === "aborted")
+        type = "aborted";
+    else if (event.state === "error")
+        type = "error";
+    const action = {
+        id: `${event.runId}-${event.seq}`,
+        runId: event.runId,
+        sessionKey: event.sessionKey,
+        seq: event.seq,
+        type,
+        eventType: "chat",
+        timestamp: Date.now(),
+    };
+    if (event.state === "final") {
+        if (event.usage) {
+            action.inputTokens = event.usage.inputTokens;
+            action.outputTokens = event.usage.outputTokens;
+        }
+        if (event.stopReason) {
+            action.stopReason = event.stopReason;
+        }
+    }
+    if (event.message) {
+        if (typeof event.message === "string") {
+            action.content = event.message;
+        }
+        else if (typeof event.message === "object") {
+            const msg = event.message;
+            if (Array.isArray(msg.content)) {
+                const texts = [];
+                for (const block of msg.content) {
+                    if (typeof block === "object" && block) {
+                        const b = block;
+                        if (b.type === "text" && typeof b.text === "string") {
+                            texts.push(b.text);
+                        }
+                        else if (b.type === "tool_use") {
+                            action.type = "tool_call";
+                            action.toolName = String(b.name || "unknown");
+                            action.toolArgs = b.input;
+                        }
+                        else if (b.type === "tool_result") {
+                            action.type = "tool_result";
+                            if (typeof b.content === "string") {
+                                texts.push(b.content);
+                            }
+                        }
+                    }
+                }
+                if (texts.length > 0) {
+                    action.content = texts.join("");
+                }
+            }
+            else if (typeof msg.content === "string") {
+                action.content = msg.content;
+            }
+            else if (typeof msg.text === "string") {
+                action.content = msg.text;
+            }
+        }
+    }
+    if (event.errorMessage) {
+        action.content = event.errorMessage;
+    }
+    return action;
+}
+// ─── Agent Event Parser ──────────────────────────────────────────────────────
+export function agentEventToAction(event) {
+    const data = event.data;
+    let type = "streaming";
+    let content;
+    let toolName;
+    let toolArgs;
+    let startedAt;
+    let endedAt;
+    if (event.stream === "lifecycle") {
+        if (data.phase === "start") {
+            type = "start";
+            startedAt = typeof data.startedAt === "number" ? data.startedAt : event.ts;
+        }
+        else if (data.phase === "end") {
+            type = "complete";
+            endedAt = typeof data.endedAt === "number" ? data.endedAt : event.ts;
+        }
+    }
+    else if (data.type === "tool_use") {
+        type = "tool_call";
+        toolName = String(data.name || "unknown");
+        toolArgs = data.input;
+        content = `Tool: ${toolName}`;
+    }
+    else if (data.type === "tool_result") {
+        type = "tool_result";
+        content = String(data.content || "");
+    }
+    else if (data.type === "text" || typeof data.text === "string") {
+        type = "streaming";
+        content = String(data.text || "");
+    }
+    return {
+        id: `${event.runId}-${event.seq}`,
+        runId: event.runId,
+        sessionKey: event.sessionKey || event.stream,
+        seq: event.seq,
+        type,
+        eventType: "agent",
+        timestamp: event.ts,
+        content,
+        toolName,
+        toolArgs,
+        startedAt,
+        endedAt,
+    };
+}
+// ─── Exec Event Parser ───────────────────────────────────────────────────────
+export function execStartedToEvent(event, seq) {
+    const execId = `exec-${event.runId}-${event.pid}`;
+    const timestamp = Date.now();
+    const id = seq != null ? `${execId}-started-${seq}` : `${execId}-started-${timestamp}`;
+    return {
+        id,
+        execId,
+        runId: event.runId,
+        pid: event.pid,
+        sessionId: event.sessionId,
+        eventType: "started",
+        command: event.command,
+        startedAt: event.startedAt,
+        timestamp,
+    };
+}
+export function execOutputToEvent(event, seq) {
+    const execId = `exec-${event.runId}-${event.pid}`;
+    const timestamp = Date.now();
+    const id = seq != null ? `${execId}-output-${seq}` : `${execId}-output-${timestamp}`;
+    return {
+        id,
+        execId,
+        runId: event.runId,
+        pid: event.pid,
+        sessionId: event.sessionId,
+        eventType: "output",
+        stream: event.stream,
+        output: event.output,
+        timestamp,
+    };
+}
+export function execCompletedToEvent(event, seq) {
+    const execId = `exec-${event.runId}-${event.pid}`;
+    const timestamp = Date.now();
+    const id = seq != null
+        ? `${execId}-completed-${seq}`
+        : `${execId}-completed-${timestamp}`;
+    return {
+        id,
+        execId,
+        runId: event.runId,
+        pid: event.pid,
+        sessionId: event.sessionId,
+        eventType: "completed",
+        durationMs: event.durationMs,
+        exitCode: event.exitCode,
+        status: event.status,
+        timestamp,
+    };
+}
+export function parseGatewayEvent(eventName, payload, seq) {
+    if (eventName === "health" || eventName === "tick") {
+        return null;
+    }
+    if (eventName === "chat" && payload) {
+        const chatEvent = payload;
+        return {
+            action: chatEventToAction(chatEvent),
+            session: {
+                key: chatEvent.sessionKey,
+                status: chatEvent.state === "delta" ? "thinking" : "active",
+                lastActivityAt: Date.now(),
+            },
+        };
+    }
+    if (eventName === "agent" && payload) {
+        const agentEvent = payload;
+        if (agentEvent.stream === "lifecycle") {
+            return {
+                action: agentEventToAction(agentEvent),
+                session: agentEvent.sessionKey
+                    ? {
+                        key: agentEvent.sessionKey,
+                        status: agentEvent.data?.phase === "start" ? "thinking" : "active",
+                        lastActivityAt: Date.now(),
+                    }
+                    : undefined,
+            };
+        }
+        if (agentEvent.stream === "assistant" &&
+            typeof agentEvent.data?.text === "string") {
+            return {
+                action: agentEventToAction(agentEvent),
+                session: agentEvent.sessionKey
+                    ? {
+                        key: agentEvent.sessionKey,
+                        status: "thinking",
+                        lastActivityAt: Date.now(),
+                    }
+                    : undefined,
+            };
+        }
+        if (agentEvent.data?.type === "tool_use" ||
+            agentEvent.data?.type === "tool_result") {
+            return {
+                action: agentEventToAction(agentEvent),
+                session: agentEvent.sessionKey
+                    ? {
+                        key: agentEvent.sessionKey,
+                        status: "thinking",
+                        lastActivityAt: Date.now(),
+                    }
+                    : undefined,
+            };
+        }
+        return null;
+    }
+    if (eventName === "exec.started" && payload) {
+        const exec = payload;
+        const execEvent = execStartedToEvent(exec, seq);
+        return {
+            execEvent,
+            session: exec.sessionId
+                ? {
+                    key: exec.sessionId,
+                    status: "thinking",
+                    lastActivityAt: execEvent.timestamp,
+                }
+                : undefined,
+        };
+    }
+    if (eventName === "exec.output" && payload) {
+        const exec = payload;
+        const execEvent = execOutputToEvent(exec, seq);
+        return {
+            execEvent,
+            session: exec.sessionId
+                ? {
+                    key: exec.sessionId,
+                    lastActivityAt: execEvent.timestamp,
+                }
+                : undefined,
+        };
+    }
+    if (eventName === "exec.completed" && payload) {
+        const exec = payload;
+        const execEvent = execCompletedToEvent(exec, seq);
+        return {
+            execEvent,
+            session: exec.sessionId
+                ? {
+                    key: exec.sessionId,
+                    status: "active",
+                    lastActivityAt: execEvent.timestamp,
+                }
+                : undefined,
+        };
+    }
+    return null;
+}
+export function diagnosticUsageToSessionUpdate(event) {
+    const sessionKey = event.sessionKey || event.sessionId;
+    const now = Date.now();
+    const result = {};
+    if (sessionKey) {
+        const inputTokens = event.usage?.input ?? event.usage?.promptTokens ?? 0;
+        const outputTokens = event.usage?.output ?? 0;
+        result.session = {
+            key: sessionKey,
+            lastActivityAt: now,
+            status: "active",
+            totalInputTokens: inputTokens,
+            totalOutputTokens: outputTokens,
+        };
+        if (typeof event.costUsd === "number") {
+            result.session.totalCostUsd = event.costUsd;
+        }
+    }
+    if (typeof event.costUsd === "number" || event.usage) {
+        const actionId = `usage-${event.ts}-${event.seq}`;
+        result.action = {
+            id: actionId,
+            runId: actionId,
+            sessionKey: sessionKey || "unknown",
+            seq: event.seq,
+            type: "complete",
+            eventType: "system",
+            timestamp: event.ts,
+            inputTokens: event.usage?.input ?? event.usage?.promptTokens,
+            outputTokens: event.usage?.output,
+            costUsd: event.costUsd,
+            model: event.model,
+            provider: event.provider,
+            duration: event.durationMs,
+        };
+    }
+    return result;
+}

package/dist/collections/index.d.ts

@@ -0,0 +1,6 @@
+export type { MonitorSession, MonitorActionType, MonitorActionEventType, MonitorAction, MonitorExecEventType, MonitorExecProcessStatus, MonitorExecOutputChunk, MonitorExecEvent, MonitorExecProcess, ChatEvent, AgentEvent, ExecStartedEvent, ExecOutputEvent, ExecCompletedEvent, CollectionStats, DiagnosticUsageEvent, CostUsageTotals, CostUsageSummary, } from "./types.js";
+export { parseSessionKey } from "./types.js";
+export type { ParsedGatewayEvent, SessionInfo, ParsedDiagnosticUsage, } from "./event-parser.js";
+export { sessionInfoToMonitor, chatEventToAction, agentEventToAction, execStartedToEvent, execOutputToEvent, execCompletedToEvent, parseGatewayEvent, diagnosticUsageToSessionUpdate, } from "./event-parser.js";
+export { CollectionManager } from "./collection-manager.js";
+export { CollectionPersistence } from "./persistence.js";

package/dist/collections/index.js

@@ -0,0 +1,6 @@
+export { parseSessionKey } from "./types.js";
+export { sessionInfoToMonitor, chatEventToAction, agentEventToAction, execStartedToEvent, execOutputToEvent, execCompletedToEvent, parseGatewayEvent, diagnosticUsageToSessionUpdate, } from "./event-parser.js";
+// Collection Manager
+export { CollectionManager } from "./collection-manager.js";
+// Persistence
+export { CollectionPersistence } from "./persistence.js";

package/dist/collections/persistence.d.ts

@@ -0,0 +1,25 @@
+import type { MonitorSession, MonitorAction, MonitorExecEvent } from "./types.js";
+export declare class CollectionPersistence {
+    private stateDir;
+    private dirty;
+    private flushTimer;
+    private lastSessionsJson;
+    private pendingActions;
+    private pendingExecs;
+    constructor(stateDir: string);
+    start(): void;
+    stop(): void;
+    markDirty(): void;
+    saveSessions(sessions: MonitorSession[]): void;
+    loadSessions(): MonitorSession[];
+    queueAction(action: MonitorAction): void;
+    loadActions(): MonitorAction[];
+    queueExecEvent(event: MonitorExecEvent): void;
+    loadExecEvents(): MonitorExecEvent[];
+    flush(): void;
+    hydrate(): {
+        sessions: MonitorSession[];
+        actions: MonitorAction[];
+        execEvents: MonitorExecEvent[];
+    };
+}

package/dist/collections/persistence.js

@@ -0,0 +1,213 @@
+import fs from "node:fs";
+import path from "node:path";
+// ─── Constants ───────────────────────────────────────────────────────────────
+const COLLECTIONS_DIR_NAME = "collections";
+const SESSIONS_FILENAME = "sessions.json";
+const ACTIONS_FILENAME = "actions.jsonl";
+const EXECS_FILENAME = "execs.jsonl";
+const MAX_ACTIONS_LINES = 10000;
+const MAX_EXECS_LINES = 20000;
+const FLUSH_INTERVAL_MS = 5000;
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function resolveDir(stateDir) {
+    return path.join(stateDir, COLLECTIONS_DIR_NAME);
+}
+function resolveSessionsPath(stateDir) {
+    return path.join(resolveDir(stateDir), SESSIONS_FILENAME);
+}
+function resolveActionsPath(stateDir) {
+    return path.join(resolveDir(stateDir), ACTIONS_FILENAME);
+}
+function resolveExecsPath(stateDir) {
+    return path.join(resolveDir(stateDir), EXECS_FILENAME);
+}
+function ensureDir(stateDir) {
+    const dir = resolveDir(stateDir);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function writeAtomic(filePath, content) {
+    const tmpPath = filePath + ".tmp";
+    try {
+        fs.writeFileSync(tmpPath, content, "utf-8");
+        fs.renameSync(tmpPath, filePath);
+    }
+    catch {
+        fs.writeFileSync(filePath, content, "utf-8");
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch {
+            // Ignore cleanup failure
+        }
+    }
+}
+function appendLine(filePath, line) {
+    fs.appendFileSync(filePath, line + "\n", "utf-8");
+}
+function capJsonlFile(filePath, maxLines) {
+    if (!fs.existsSync(filePath))
+        return;
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        if (lines.length <= maxLines)
+            return;
+        const kept = lines.slice(-maxLines);
+        writeAtomic(filePath, kept.join("\n") + "\n");
+    }
+    catch {
+        // Ignore errors during cap
+    }
+}
+// ─── Persistence Class ───────────────────────────────────────────────────────
+export class CollectionPersistence {
+    stateDir;
+    dirty = false;
+    flushTimer = null;
+    // Cached data for tracking changes
+    lastSessionsJson = "";
+    pendingActions = [];
+    pendingExecs = [];
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+    }
+    start() {
+        ensureDir(this.stateDir);
+        this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+    }
+    stop() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.flush();
+    }
+    markDirty() {
+        this.dirty = true;
+    }
+    // ─── Sessions (JSON rewrite) ──────────────────────────────────────────────
+    saveSessions(sessions) {
+        const json = JSON.stringify(sessions, null, 2);
+        if (json === this.lastSessionsJson)
+            return;
+        this.lastSessionsJson = json;
+        this.dirty = true;
+    }
+    loadSessions() {
+        const filePath = resolveSessionsPath(this.stateDir);
+        if (!fs.existsSync(filePath))
+            return [];
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const parsed = JSON.parse(content);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+            return [];
+        }
+        catch {
+            return [];
+        }
+    }
+    // ─── Actions (JSONL append) ───────────────────────────────────────────────
+    queueAction(action) {
+        this.pendingActions.push(action);
+        this.dirty = true;
+    }
+    loadActions() {
+        const filePath = resolveActionsPath(this.stateDir);
+        if (!fs.existsSync(filePath))
+            return [];
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.trim().split("\n").filter(Boolean);
+            const actions = [];
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed && typeof parsed.id === "string") {
+                        actions.push(parsed);
+                    }
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            return actions;
+        }
+        catch {
+            return [];
+        }
+    }
+    // ─── Execs (JSONL append) ─────────────────────────────────────────────────
+    queueExecEvent(event) {
+        this.pendingExecs.push(event);
+        this.dirty = true;
+    }
+    loadExecEvents() {
+        const filePath = resolveExecsPath(this.stateDir);
+        if (!fs.existsSync(filePath))
+            return [];
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.trim().split("\n").filter(Boolean);
+            const events = [];
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed && typeof parsed.id === "string") {
+                        events.push(parsed);
+                    }
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            return events;
+        }
+        catch {
+            return [];
+        }
+    }
+    // ─── Flush ────────────────────────────────────────────────────────────────
+    flush() {
+        if (!this.dirty && this.pendingActions.length === 0 && this.pendingExecs.length === 0) {
+            return;
+        }
+        ensureDir(this.stateDir);
+        // Write sessions if changed
+        if (this.lastSessionsJson) {
+            const filePath = resolveSessionsPath(this.stateDir);
+            writeAtomic(filePath, this.lastSessionsJson);
+        }
+        // Append pending actions
+        if (this.pendingActions.length > 0) {
+            const filePath = resolveActionsPath(this.stateDir);
+            for (const action of this.pendingActions) {
+                appendLine(filePath, JSON.stringify(action));
+            }
+            this.pendingActions = [];
+            capJsonlFile(filePath, MAX_ACTIONS_LINES);
+        }
+        // Append pending exec events
+        if (this.pendingExecs.length > 0) {
+            const filePath = resolveExecsPath(this.stateDir);
+            for (const event of this.pendingExecs) {
+                appendLine(filePath, JSON.stringify(event));
+            }
+            this.pendingExecs = [];
+            capJsonlFile(filePath, MAX_EXECS_LINES);
+        }
+        this.dirty = false;
+    }
+    // ─── Full Hydration ───────────────────────────────────────────────────────
+    hydrate() {
+        return {
+            sessions: this.loadSessions(),
+            actions: this.loadActions(),
+            execEvents: this.loadExecEvents(),
+        };
+    }
+}