@goondan/cli 0.0.3-alpha6 → 0.0.3-alpha8

package/dist/services/studio.js

@@ -0,0 +1,751 @@
+import { createServer } from 'node:http';
+import path from 'node:path';
+import { readdir, stat } from 'node:fs/promises';
+import { STUDIO_CSS, STUDIO_HTML, STUDIO_JS } from '../studio/assets.js';
+import { exists, isObjectRecord, readTextFileIfExists } from '../utils.js';
+import { resolveStateRoot } from './config.js';
+function sanitizeInstanceKey(instanceKey) {
+    return instanceKey.replace(/[^a-zA-Z0-9_:-]/g, '-').slice(0, 128);
+}
+function nowIso(offset = 0) {
+    return new Date(Date.now() + offset).toISOString();
+}
+function normalizeTimestamp(input, fallbackOffset) {
+    if (typeof input === 'string') {
+        const parsed = Date.parse(input);
+        if (!Number.isNaN(parsed)) {
+            return new Date(parsed).toISOString();
+        }
+    }
+    return nowIso(fallbackOffset);
+}
+function toMillis(input) {
+    const parsed = Date.parse(input);
+    if (Number.isNaN(parsed)) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return parsed;
+}
+function toDetailText(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const texts = value
+            .map((item) => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            if (!isObjectRecord(item)) {
+                return '';
+            }
+            const textValue = item['text'];
+            return typeof textValue === 'string' ? textValue : '';
+        })
+            .filter((text) => text.length > 0);
+        return texts.join(' ');
+    }
+    if (isObjectRecord(value)) {
+        const textValue = value['text'];
+        if (typeof textValue === 'string') {
+            return textValue;
+        }
+    }
+    return '';
+}
+function messageFromUnknown(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    const createdAt = value['createdAt'];
+    const source = value['source'];
+    const data = value['data'];
+    if (typeof createdAt !== 'string' || !isObjectRecord(source) || !isObjectRecord(data)) {
+        return undefined;
+    }
+    const sourceType = source['type'];
+    if (typeof sourceType !== 'string') {
+        return undefined;
+    }
+    const role = data['role'];
+    const content = toDetailText(data['content']);
+    const extensionName = source['extensionName'];
+    const toolName = source['toolName'];
+    let finalSourceType = sourceType;
+    if (typeof role === 'string' && role.length > 0 && sourceType === 'assistant') {
+        finalSourceType = role;
+    }
+    return {
+        createdAt,
+        sourceType: finalSourceType,
+        toolName: typeof toolName === 'string' ? toolName : undefined,
+        extensionName: typeof extensionName === 'string' ? extensionName : undefined,
+        content,
+    };
+}
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readJsonLines(filePath) {
+    const raw = await readTextFileIfExists(filePath);
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map(parseJsonLine)
+        .filter((line) => line !== undefined);
+}
+function classifyParticipantKind(sourceType) {
+    if (sourceType === 'user') {
+        return 'user';
+    }
+    if (sourceType === 'assistant') {
+        return 'assistant';
+    }
+    if (sourceType === 'tool') {
+        return 'tool';
+    }
+    if (sourceType === 'extension') {
+        return 'extension';
+    }
+    if (sourceType === 'system') {
+        return 'system';
+    }
+    return 'unknown';
+}
+function registerParticipant(participants, id, label, kind, at) {
+    const existing = participants.get(id);
+    if (!existing) {
+        participants.set(id, {
+            id,
+            label,
+            kind,
+            lastSeenAt: at,
+            order: participants.size,
+        });
+        return;
+    }
+    if (toMillis(at) >= toMillis(existing.lastSeenAt)) {
+        existing.lastSeenAt = at;
+    }
+}
+function edgeKeyFor(from, to) {
+    if (from <= to) {
+        return {
+            key: `${from}|${to}`,
+            a: from,
+            b: to,
+            forward: true,
+        };
+    }
+    return {
+        key: `${to}|${from}`,
+        a: to,
+        b: from,
+        forward: false,
+    };
+}
+function registerInteraction(interactions, from, to, at, kind, detail) {
+    if (from.length === 0 || to.length === 0 || from === to) {
+        return;
+    }
+    const edge = edgeKeyFor(from, to);
+    const existing = interactions.get(edge.key);
+    const history = {
+        at,
+        from,
+        to,
+        direction: edge.forward ? 'a->b' : 'b->a',
+        kind,
+        detail,
+    };
+    if (!existing) {
+        interactions.set(edge.key, {
+            key: edge.key,
+            a: edge.a,
+            b: edge.b,
+            total: 1,
+            lastSeenAt: at,
+            direction: edge.forward ? 'a->b' : 'b->a',
+            history: [history],
+            forwardSeen: edge.forward,
+            backwardSeen: !edge.forward,
+        });
+        return;
+    }
+    existing.total += 1;
+    if (toMillis(at) >= toMillis(existing.lastSeenAt)) {
+        existing.lastSeenAt = at;
+    }
+    existing.history.push(history);
+    if (edge.forward) {
+        existing.forwardSeen = true;
+    }
+    else {
+        existing.backwardSeen = true;
+    }
+    if (existing.forwardSeen && existing.backwardSeen) {
+        existing.direction = 'undirected';
+    }
+    else {
+        existing.direction = existing.forwardSeen ? 'a->b' : 'b->a';
+    }
+}
+function pushTimeline(timeline, entry, sequence) {
+    timeline.push({
+        entry,
+        sortAt: toMillis(entry.at),
+        sequence,
+    });
+}
+function fromMessageToRoute(message, instanceKey, defaultAgentId) {
+    const userId = `user:${instanceKey}`;
+    const systemId = 'system:runtime';
+    if (message.sourceType === 'user') {
+        return {
+            from: userId,
+            to: defaultAgentId,
+            kind: 'message.user',
+            detail: message.content,
+        };
+    }
+    if (message.sourceType === 'tool') {
+        const toolName = message.toolName ?? 'unknown';
+        return {
+            from: `tool:${toolName}`,
+            to: defaultAgentId,
+            kind: 'message.tool',
+            detail: message.content,
+        };
+    }
+    if (message.sourceType === 'extension') {
+        const extensionName = message.extensionName ?? 'unknown';
+        return {
+            from: `extension:${extensionName}`,
+            to: defaultAgentId,
+            kind: 'message.extension',
+            detail: message.content,
+        };
+    }
+    if (message.sourceType === 'system') {
+        return {
+            from: systemId,
+            to: defaultAgentId,
+            kind: 'message.system',
+            detail: message.content,
+        };
+    }
+    return {
+        from: defaultAgentId,
+        to: userId,
+        kind: 'message.assistant',
+        detail: message.content,
+    };
+}
+function runtimeEventRoute(event) {
+    const type = event['type'];
+    const agentName = event['agentName'];
+    if (typeof type !== 'string' || typeof agentName !== 'string') {
+        return undefined;
+    }
+    const agentId = `agent:${agentName}`;
+    if (type === 'tool.called') {
+        const toolName = event['toolName'];
+        return {
+            from: agentId,
+            to: `tool:${typeof toolName === 'string' ? toolName : 'unknown'}`,
+            detail: typeof toolName === 'string' ? toolName : '',
+        };
+    }
+    if (type === 'tool.completed' || type === 'tool.failed') {
+        const toolName = event['toolName'];
+        const status = event['status'];
+        const suffix = typeof status === 'string' ? ` (${status})` : '';
+        return {
+            from: `tool:${typeof toolName === 'string' ? toolName : 'unknown'}`,
+            to: agentId,
+            detail: `${typeof toolName === 'string' ? toolName : 'unknown'}${suffix}`,
+        };
+    }
+    return {
+        from: agentId,
+        to: 'system:runtime',
+        detail: type,
+    };
+}
+function parseConnectorLogLine(line, fallbackOffset) {
+    const pattern = /\[goondan-runtime\]\[([^/\]]+)\/([^\]]+)\] emitted event name=([^\s]+) instanceKey=([^\s]+)/u;
+    const match = pattern.exec(line);
+    if (!match) {
+        return undefined;
+    }
+    const connectionName = match[1] ?? '';
+    const connectorName = match[2] ?? '';
+    const eventName = match[3] ?? '';
+    if (connectionName.length === 0 || connectorName.length === 0 || eventName.length === 0) {
+        return undefined;
+    }
+    const timestampMatch = line.match(/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)/u);
+    const at = normalizeTimestamp(timestampMatch ? timestampMatch[1] : undefined, fallbackOffset);
+    return {
+        at,
+        connectionName,
+        connectorName,
+        eventName,
+    };
+}
+async function resolveInstanceLocations(stateRoot, instanceKey) {
+    const safeKey = sanitizeInstanceKey(instanceKey);
+    const results = [];
+    const seen = new Set();
+    const workspacesRoot = path.join(stateRoot, 'workspaces');
+    if (await exists(workspacesRoot)) {
+        const workspaces = await readdir(workspacesRoot, { withFileTypes: true });
+        for (const workspace of workspaces) {
+            if (!workspace.isDirectory()) {
+                continue;
+            }
+            const workspaceName = workspace.name;
+            const candidates = [
+                path.join(workspacesRoot, workspaceName, 'instances', safeKey),
+                path.join(workspacesRoot, workspaceName, 'instances', instanceKey),
+            ];
+            for (const candidate of candidates) {
+                if (!(await exists(candidate))) {
+                    continue;
+                }
+                if (seen.has(candidate)) {
+                    continue;
+                }
+                seen.add(candidate);
+                results.push({
+                    workspaceName,
+                    instancePath: candidate,
+                });
+            }
+        }
+    }
+    const legacyRoot = path.join(stateRoot, 'instances');
+    if (await exists(legacyRoot)) {
+        const workspaceCandidates = await readdir(legacyRoot, { withFileTypes: true });
+        for (const workspace of workspaceCandidates) {
+            if (!workspace.isDirectory()) {
+                continue;
+            }
+            const workspaceName = workspace.name;
+            const candidates = [
+                path.join(legacyRoot, workspaceName, safeKey),
+                path.join(legacyRoot, workspaceName, instanceKey),
+            ];
+            for (const candidate of candidates) {
+                if (!(await exists(candidate))) {
+                    continue;
+                }
+                if (seen.has(candidate)) {
+                    continue;
+                }
+                seen.add(candidate);
+                results.push({
+                    workspaceName,
+                    instancePath: candidate,
+                });
+            }
+        }
+    }
+    return results;
+}
+function parseInstanceMetadataAgent(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isObjectRecord(parsed)) {
+            return undefined;
+        }
+        const agentName = parsed['agentName'];
+        if (typeof agentName === 'string' && agentName.length > 0) {
+            return agentName;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function compareTimeline(a, b) {
+    if (a.sortAt !== b.sortAt) {
+        return a.sortAt - b.sortAt;
+    }
+    return a.sequence - b.sequence;
+}
+function finalizeParticipants(participants) {
+    return [...participants.values()]
+        .sort((a, b) => {
+        const timeGap = toMillis(b.lastSeenAt) - toMillis(a.lastSeenAt);
+        if (timeGap !== 0) {
+            return timeGap;
+        }
+        return a.order - b.order;
+    })
+        .map((item) => ({
+        id: item.id,
+        label: item.label,
+        kind: item.kind,
+        lastSeenAt: item.lastSeenAt,
+    }));
+}
+function finalizeInteractions(interactions) {
+    return [...interactions.values()]
+        .sort((a, b) => toMillis(b.lastSeenAt) - toMillis(a.lastSeenAt))
+        .map((item) => ({
+        key: item.key,
+        a: item.a,
+        b: item.b,
+        total: item.total,
+        lastSeenAt: item.lastSeenAt,
+        direction: item.direction,
+        history: [...item.history].sort((x, y) => toMillis(x.at) - toMillis(y.at)),
+    }));
+}
+function normalizeHostForDisplay(host) {
+    if (host === '0.0.0.0' || host === '::') {
+        return '127.0.0.1';
+    }
+    if (host.includes(':') && !host.startsWith('[')) {
+        return `[${host}]`;
+    }
+    return host;
+}
+function parseRecentLimit(value) {
+    if (value === null || value.trim().length === 0) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return Math.min(parsed, 200);
+}
+function writeJson(res, statusCode, payload) {
+    const body = JSON.stringify(payload);
+    res.statusCode = statusCode;
+    res.setHeader('content-type', 'application/json; charset=utf-8');
+    res.setHeader('cache-control', 'no-store');
+    res.end(body);
+}
+function writeText(res, statusCode, contentType, body) {
+    res.statusCode = statusCode;
+    res.setHeader('content-type', contentType);
+    res.setHeader('cache-control', 'no-store');
+    res.end(body);
+}
+function notFound(res) {
+    writeJson(res, 404, {
+        error: 'not_found',
+        message: '요청한 리소스를 찾을 수 없습니다.',
+    });
+}
+export class DefaultStudioService {
+    env;
+    instances;
+    constructor(env, instances) {
+        this.env = env;
+        this.instances = instances;
+    }
+    async listInstances(request) {
+        const rows = await this.instances.list({
+            limit: 200,
+            all: true,
+            stateRoot: request.stateRoot,
+        });
+        return rows.map((row) => ({
+            key: row.key,
+            status: row.status,
+            agent: row.agent,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        }));
+    }
+    async loadVisualization(request) {
+        const stateRoot = resolveStateRoot(request.stateRoot, this.env);
+        const instanceLocations = await resolveInstanceLocations(stateRoot, request.instanceKey);
+        const participants = new Map();
+        const interactions = new Map();
+        const timeline = [];
+        let sequence = 0;
+        const defaultAgentId = 'agent:orchestrator';
+        registerParticipant(participants, defaultAgentId, 'orchestrator', 'agent', nowIso());
+        registerParticipant(participants, `user:${request.instanceKey}`, 'user', 'user', nowIso(1));
+        const knownAgents = new Set(['orchestrator']);
+        for (const location of instanceLocations) {
+            const metadataPath = path.join(location.instancePath, 'metadata.json');
+            const metadataRaw = await readTextFileIfExists(metadataPath);
+            const metadataAgent = metadataRaw ? parseInstanceMetadataAgent(metadataRaw) : undefined;
+            if (metadataAgent) {
+                knownAgents.add(metadataAgent);
+                registerParticipant(participants, `agent:${metadataAgent}`, metadataAgent, 'agent', nowIso(sequence));
+            }
+            const basePath = path.join(location.instancePath, 'messages', 'base.jsonl');
+            const eventsPath = path.join(location.instancePath, 'messages', 'events.jsonl');
+            const runtimeEventsPath = path.join(location.instancePath, 'messages', 'runtime-events.jsonl');
+            const baseRows = await readJsonLines(basePath);
+            for (const row of baseRows) {
+                const message = messageFromUnknown(row);
+                if (!message) {
+                    continue;
+                }
+                const at = normalizeTimestamp(message.createdAt, sequence);
+                const principalAgent = metadataAgent ?? 'orchestrator';
+                const principalAgentId = `agent:${principalAgent}`;
+                registerParticipant(participants, principalAgentId, principalAgent, 'agent', at);
+                const routed = fromMessageToRoute(message, request.instanceKey, principalAgentId);
+                registerParticipant(participants, routed.from, routed.from.replace(/^[^:]+:/u, ''), classifyParticipantKind(message.sourceType), at);
+                registerParticipant(participants, routed.to, routed.to.replace(/^[^:]+:/u, ''), routed.to.startsWith('agent:') ? 'agent' : 'unknown', at);
+                registerInteraction(interactions, routed.from, routed.to, at, routed.kind, routed.detail);
+                pushTimeline(timeline, {
+                    at,
+                    kind: 'message',
+                    source: routed.from,
+                    target: routed.to,
+                    subtype: routed.kind,
+                    detail: routed.detail,
+                }, sequence);
+                sequence += 1;
+            }
+            const eventRows = await readJsonLines(eventsPath);
+            for (const row of eventRows) {
+                if (!isObjectRecord(row)) {
+                    continue;
+                }
+                const eventType = row['type'];
+                if (typeof eventType !== 'string') {
+                    continue;
+                }
+                if (eventType === 'append') {
+                    const message = messageFromUnknown(row['message']);
+                    if (!message) {
+                        continue;
+                    }
+                    const at = normalizeTimestamp(message.createdAt, sequence);
+                    const principalAgent = metadataAgent ?? 'orchestrator';
+                    const principalAgentId = `agent:${principalAgent}`;
+                    const routed = fromMessageToRoute(message, request.instanceKey, principalAgentId);
+                    registerParticipant(participants, routed.from, routed.from.replace(/^[^:]+:/u, ''), classifyParticipantKind(message.sourceType), at);
+                    registerParticipant(participants, routed.to, routed.to.replace(/^[^:]+:/u, ''), routed.to.startsWith('agent:') ? 'agent' : 'unknown', at);
+                    registerInteraction(interactions, routed.from, routed.to, at, 'message.append', routed.detail);
+                    pushTimeline(timeline, {
+                        at,
+                        kind: 'message',
+                        source: routed.from,
+                        target: routed.to,
+                        subtype: 'message.append',
+                        detail: routed.detail,
+                    }, sequence);
+                    sequence += 1;
+                    continue;
+                }
+                const at = nowIso(sequence);
+                pushTimeline(timeline, {
+                    at,
+                    kind: 'message',
+                    source: 'system:runtime',
+                    target: metadataAgent ? `agent:${metadataAgent}` : defaultAgentId,
+                    subtype: `event.${eventType}`,
+                    detail: `message event: ${eventType}`,
+                }, sequence);
+                sequence += 1;
+            }
+            const runtimeRows = await readJsonLines(runtimeEventsPath);
+            for (const row of runtimeRows) {
+                if (!isObjectRecord(row)) {
+                    continue;
+                }
+                const at = normalizeTimestamp(row['timestamp'], sequence);
+                const routed = runtimeEventRoute(row);
+                if (!routed) {
+                    continue;
+                }
+                const sourceLabel = routed.from.replace(/^[^:]+:/u, '');
+                const targetLabel = routed.to.replace(/^[^:]+:/u, '');
+                registerParticipant(participants, routed.from, sourceLabel, routed.from.startsWith('agent:') ? 'agent' : routed.from.startsWith('tool:') ? 'tool' : 'system', at);
+                registerParticipant(participants, routed.to, targetLabel, routed.to.startsWith('agent:') ? 'agent' : routed.to.startsWith('tool:') ? 'tool' : 'system', at);
+                const subtype = typeof row['type'] === 'string' ? row['type'] : 'runtime.event';
+                registerInteraction(interactions, routed.from, routed.to, at, subtype, routed.detail);
+                pushTimeline(timeline, {
+                    at,
+                    kind: 'runtime-event',
+                    source: routed.from,
+                    target: routed.to,
+                    subtype,
+                    detail: routed.detail,
+                }, sequence);
+                sequence += 1;
+            }
+        }
+        const connectorEvents = await this.readConnectorEventsFromLogs(stateRoot, request.instanceKey);
+        const primaryAgent = knownAgents.values().next().value ?? 'orchestrator';
+        const primaryAgentId = `agent:${primaryAgent}`;
+        for (const event of connectorEvents) {
+            const source = `connector:${event.connectorName}`;
+            const target = primaryAgentId;
+            const detail = `${event.connectionName}/${event.connectorName} -> ${event.eventName}`;
+            registerParticipant(participants, source, event.connectorName, 'connector', event.at);
+            registerParticipant(participants, target, primaryAgent, 'agent', event.at);
+            registerInteraction(interactions, source, target, event.at, 'connector.emitted', detail);
+            pushTimeline(timeline, {
+                at: event.at,
+                kind: 'connector-log',
+                source,
+                target,
+                subtype: 'connector.emitted',
+                detail,
+            }, sequence);
+            sequence += 1;
+        }
+        timeline.sort(compareTimeline);
+        const entries = timeline.map((item) => item.entry);
+        const recentLimit = request.maxRecentEvents ?? 20;
+        const recentEvents = entries.slice(Math.max(0, entries.length - recentLimit));
+        return {
+            instanceKey: request.instanceKey,
+            participants: finalizeParticipants(participants),
+            interactions: finalizeInteractions(interactions),
+            timeline: entries,
+            recentEvents,
+        };
+    }
+    async startServer(request) {
+        const host = request.host;
+        const port = request.port;
+        const stateRoot = resolveStateRoot(request.stateRoot, this.env);
+        const server = createServer(async (req, res) => {
+            await this.handleHttpRequest(req, res, stateRoot);
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(port, host, () => {
+                server.off('error', reject);
+                resolve();
+            });
+        });
+        const closed = new Promise((resolve) => {
+            server.once('close', () => {
+                resolve();
+            });
+        });
+        const close = async () => await new Promise((resolve, reject) => {
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(undefined);
+            });
+        });
+        const addr = server.address();
+        const boundPort = typeof addr === 'object' && addr && typeof addr.port === 'number' ? addr.port : port;
+        const displayHost = normalizeHostForDisplay(host);
+        return {
+            url: `http://${displayHost}:${String(boundPort)}`,
+            close,
+            closed,
+        };
+    }
+    async handleHttpRequest(req, res, stateRoot) {
+        const method = req.method ?? 'GET';
+        const url = new URL(req.url ?? '/', 'http://studio.local');
+        const pathname = url.pathname;
+        if (pathname === '/favicon.ico') {
+            res.statusCode = 204;
+            res.end();
+            return;
+        }
+        if (method === 'GET' && pathname === '/') {
+            writeText(res, 200, 'text/html; charset=utf-8', STUDIO_HTML);
+            return;
+        }
+        if (method === 'GET' && pathname === '/studio.css') {
+            writeText(res, 200, 'text/css; charset=utf-8', STUDIO_CSS);
+            return;
+        }
+        if (method === 'GET' && pathname === '/studio.js') {
+            writeText(res, 200, 'text/javascript; charset=utf-8', STUDIO_JS);
+            return;
+        }
+        const segments = pathname
+            .split('/')
+            .map((segment) => segment.trim())
+            .filter((segment) => segment.length > 0);
+        if (method === 'GET' && segments.length === 2 && segments[0] === 'api' && segments[1] === 'instances') {
+            const items = await this.listInstances({ stateRoot });
+            writeJson(res, 200, {
+                items,
+                polledAt: new Date().toISOString(),
+            });
+            return;
+        }
+        if (method === 'GET' &&
+            segments.length === 4 &&
+            segments[0] === 'api' &&
+            segments[1] === 'instances' &&
+            segments[3] === 'visualization') {
+            const encodedKey = segments[2];
+            const instanceKey = decodeURIComponent(encodedKey ?? '');
+            if (!instanceKey) {
+                writeJson(res, 400, {
+                    error: 'invalid_instance_key',
+                    message: 'instance key가 비어 있습니다.',
+                });
+                return;
+            }
+            const maxRecentEvents = parseRecentLimit(url.searchParams.get('recent'));
+            const visualization = await this.loadVisualization({
+                stateRoot,
+                instanceKey,
+                maxRecentEvents,
+            });
+            writeJson(res, 200, visualization);
+            return;
+        }
+        notFound(res);
+    }
+    async readConnectorEventsFromLogs(stateRoot, instanceKey) {
+        const events = [];
+        const logDir = path.join(stateRoot, 'runtime', 'logs', instanceKey);
+        if (!(await exists(logDir))) {
+            return events;
+        }
+        const files = await readdir(logDir, { withFileTypes: true });
+        let sequence = 0;
+        for (const file of files) {
+            if (!file.isFile() || !file.name.endsWith('.log')) {
+                continue;
+            }
+            const fullPath = path.join(logDir, file.name);
+            const content = await readTextFileIfExists(fullPath);
+            if (!content) {
+                continue;
+            }
+            const stats = await stat(fullPath);
+            const baseOffset = stats.mtime.getTime();
+            const lines = content.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
+            for (const line of lines) {
+                const parsed = parseConnectorLogLine(line, sequence + Math.max(1, Math.trunc(baseOffset / 1000)));
+                if (!parsed) {
+                    sequence += 1;
+                    continue;
+                }
+                events.push(parsed);
+                sequence += 1;
+            }
+        }
+        return events.sort((a, b) => toMillis(a.at) - toMillis(b.at));
+    }
+}
+//# sourceMappingURL=studio.js.map