@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/debug/reader/log-reader.js

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview Log Reader
+ *
+ * Reads log files with support for streaming and filtering.
+ */
+import * as fs from 'fs';
+import * as readline from 'readline';
+import * as path from 'path';
+import { glob } from 'glob';
+/**
+ * Default XDG log directory
+ */
+const DEFAULT_LOG_DIR = '.local/share/roy-agent/logs';
+/**
+ * Get XDG data home directory
+ */
+export function getXDGDataHome() {
+    return process.env.XDG_DATA_HOME ||
+        path.join(process.env.HOME || '/home/' + (process.env.USER || 'user'), '.local', 'share');
+}
+/**
+ * Log Reader for reading and parsing log files
+ */
+export class LogReader {
+    logDir;
+    constructor(options) {
+        this.logDir = options?.logDir ||
+            path.join(getXDGDataHome(), 'roy-agent', 'logs');
+    }
+    /**
+     * Get the full path to a log file
+     */
+    getLogPath(filename) {
+        if (!filename) {
+            return path.join(this.logDir, 'app.log');
+        }
+        // If absolute path, use directly
+        if (path.isAbsolute(filename)) {
+            return filename;
+        }
+        return path.join(this.logDir, filename);
+    }
+    /**
+     * Find log files matching a pattern
+     *
+     * Uses forward slashes for glob patterns to ensure cross-platform compatibility.
+     * The glob library requires forward slashes regardless of OS.
+     */
+    async findLogFiles(pattern = '*.log') {
+        try {
+            // Use forward slashes for glob pattern to ensure Windows compatibility
+            const normalizedDir = this.logDir.replace(/\\/g, "/");
+            const fullPattern = `${normalizedDir}/${pattern}`;
+            const files = await glob(fullPattern);
+            return files.sort(); // Sort by name
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get default log directory
+     */
+    getDefaultLogDir() {
+        return this.logDir;
+    }
+    /**
+     * Read lines from a log file with optional filtering
+     */
+    async *readLines(filepath, options) {
+        const sinceTime = options?.since ? this.parseTime(options.since) : null;
+        const untilTime = options?.until ? this.parseTime(options.until) : null;
+        // Check if file exists
+        if (!fs.existsSync(filepath)) {
+            return;
+        }
+        const fileStream = fs.createReadStream(filepath, { encoding: 'utf-8' });
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        try {
+            for await (const line of rl) {
+                if (!line.trim())
+                    continue;
+                // Filter by time if specified
+                if (sinceTime || untilTime) {
+                    const lineTime = this.extractTimestamp(line);
+                    if (lineTime) {
+                        if (sinceTime && lineTime < sinceTime)
+                            continue;
+                        if (untilTime && lineTime > untilTime)
+                            continue;
+                    }
+                }
+                yield line;
+            }
+        }
+        finally {
+            rl.close();
+            fileStream.destroy();
+        }
+    }
+    /**
+     * Extract timestamp from a log line
+     */
+    extractTimestamp(line) {
+        // Match format: 2026-04-08 19:12:36.134 or 2026-04-08T19:12:36.134
+        const match = line.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})/);
+        if (!match)
+            return null;
+        const datePart = match[1];
+        const timePart = match[2]; // Keep original format (10:00:00)
+        const isoString = `${datePart}T${timePart}`;
+        const timestamp = new Date(isoString).getTime();
+        return isNaN(timestamp) ? null : timestamp;
+    }
+    /**
+     * Parse time string to timestamp
+     * Supports ISO format and relative time like "1h", "30m"
+     */
+    parseTime(timeStr) {
+        const now = Date.now();
+        // Normalize the time string (replace T with space for parsing)
+        const normalizedStr = timeStr.replace('T', ' ');
+        // Try parsing as absolute time
+        const absoluteTime = new Date(normalizedStr).getTime();
+        if (!isNaN(absoluteTime) && absoluteTime > 0) {
+            return absoluteTime;
+        }
+        // Also try original format
+        const originalTime = new Date(timeStr).getTime();
+        if (!isNaN(originalTime) && originalTime > 0) {
+            return originalTime;
+        }
+        // Parse relative time
+        const relativeMatch = timeStr.match(/^(\d+)([hms])$/);
+        if (relativeMatch) {
+            const value = parseInt(relativeMatch[1], 10);
+            const unit = relativeMatch[2];
+            switch (unit) {
+                case 'h': return now - value * 60 * 60 * 1000;
+                case 'm': return now - value * 60 * 1000;
+                case 's': return now - value * 1000;
+            }
+        }
+        // Default to current time if parsing fails
+        return now;
+    }
+    /**
+     * Read file content directly (for small files)
+     */
+    async readFile(filepath) {
+        return fs.promises.readFile(filepath, 'utf-8');
+    }
+    /**
+     * Check if a log file exists
+     */
+    exists(filepath) {
+        return fs.existsSync(filepath);
+    }
+}
+//# sourceMappingURL=log-reader.js.map

package/dist/core/src/env/debug/reader/log-reader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=log-reader.test.d.ts.map

package/dist/core/src/env/debug/reader/log-reader.test.js

@@ -0,0 +1,132 @@
+import { describe, expect, test, beforeAll, afterAll } from 'bun:test';
+import { writeFileSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+import { LogReader } from "./log-reader.js";
+describe('LogReader', () => {
+    const testDir = '/tmp/roy-debug-test';
+    let reader;
+    beforeAll(() => {
+        mkdirSync(testDir, { recursive: true });
+        reader = new LogReader({ logDir: testDir });
+    });
+    afterAll(() => {
+        rmSync(testDir, { recursive: true });
+    });
+    describe('getLogPath', () => {
+        test('should return default app.log path', () => {
+            const path = reader.getLogPath();
+            expect(path).toContain('app.log');
+        });
+        test('should return custom filename path', () => {
+            const path = reader.getLogPath('custom.log');
+            expect(path).toContain('custom.log');
+        });
+        test('should use absolute path directly', () => {
+            const absPath = '/absolute/path/server.log';
+            const path = reader.getLogPath(absPath);
+            expect(path).toBe(absPath);
+        });
+    });
+    describe('findLogFiles', () => {
+        test('should return array of files', async () => {
+            const files = await reader.findLogFiles();
+            expect(Array.isArray(files)).toBe(true);
+        });
+        test('should handle custom pattern', async () => {
+            // Create test log file
+            writeFileSync(join(testDir, 'custom.log'), 'test log');
+            const files = await reader.findLogFiles('custom.log');
+            expect(Array.isArray(files)).toBe(true);
+        });
+        test('should use forward slashes for glob pattern (Windows compatibility)', async () => {
+            // Create test log files
+            writeFileSync(join(testDir, 'app.log'), 'test');
+            writeFileSync(join(testDir, 'error.log'), 'test');
+            const files = await reader.findLogFiles('*.log');
+            // Verify files are found (proves glob pattern works)
+            expect(files.length).toBeGreaterThanOrEqual(2);
+            // Verify returned paths use forward slashes (not backslashes)
+            for (const file of files) {
+                expect(file).not.toContain('\\');
+                expect(file).toContain('/');
+            }
+        });
+    });
+    describe('readLines', () => {
+        test('should read lines from file', async () => {
+            const testFile = join(testDir, 'read-test.log');
+            writeFileSync(testFile, 'line1\nline2\nline3\n');
+            const lines = [];
+            for await (const line of reader.readLines(testFile)) {
+                lines.push(line);
+            }
+            expect(lines).toEqual(['line1', 'line2', 'line3']);
+        });
+        test('should handle empty file', async () => {
+            const testFile = join(testDir, 'empty.log');
+            writeFileSync(testFile, '');
+            const lines = [];
+            for await (const line of reader.readLines(testFile)) {
+                lines.push(line);
+            }
+            expect(lines).toEqual([]);
+        });
+        test('should handle file with trailing newline', async () => {
+            const testFile = join(testDir, 'trailing.log');
+            writeFileSync(testFile, 'line1\nline2\n');
+            const lines = [];
+            for await (const line of reader.readLines(testFile)) {
+                lines.push(line);
+            }
+            expect(lines).toEqual(['line1', 'line2']);
+        });
+    });
+    describe('filterByTime', () => {
+        test('should filter by since time', async () => {
+            const testFile = join(testDir, 'time-filter.log');
+            writeFileSync(testFile, '2026-04-08 10:00:00.000 line1\n' +
+                '2026-04-08 11:00:00.000 line2\n' +
+                '2026-04-08 12:00:00.000 line3\n');
+            const lines = [];
+            for await (const line of reader.readLines(testFile, {
+                since: '2026-04-08T11:00:00'
+            })) {
+                lines.push(line);
+            }
+            expect(lines.length).toBe(2);
+            expect(lines[0]).toContain('11:00:00');
+            expect(lines[1]).toContain('12:00:00');
+        });
+        test('should filter by until time', async () => {
+            const testFile = join(testDir, 'until-filter.log');
+            writeFileSync(testFile, '2026-04-08 10:00:00.000 line1\n' +
+                '2026-04-08 11:00:00.000 line2\n' +
+                '2026-04-08 12:00:00.000 line3\n');
+            const lines = [];
+            for await (const line of reader.readLines(testFile, {
+                until: '2026-04-08T11:30:00'
+            })) {
+                lines.push(line);
+            }
+            expect(lines.length).toBe(2);
+            expect(lines[0]).toContain('10:00:00');
+            expect(lines[1]).toContain('11:00:00');
+        });
+        test('should filter by both since and until', async () => {
+            const testFile = join(testDir, 'range-filter.log');
+            writeFileSync(testFile, '2026-04-08 10:00:00.000 line1\n' +
+                '2026-04-08 11:00:00.000 line2\n' +
+                '2026-04-08 12:00:00.000 line3\n');
+            const lines = [];
+            for await (const line of reader.readLines(testFile, {
+                since: '2026-04-08T10:30:00',
+                until: '2026-04-08T11:30:00'
+            })) {
+                lines.push(line);
+            }
+            expect(lines.length).toBe(1);
+            expect(lines[0]).toContain('11:00:00');
+        });
+    });
+});
+//# sourceMappingURL=log-reader.test.js.map

package/dist/core/src/env/debug/reader/span-db-reader.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Span DB Reader - Read spans from SQLite database
+ *
+ * This reader fetches trace data directly from SQLite span storage,
+ * which is used for persisting spans in production environments.
+ */
+import type { TraceEntry, TraceSummary } from '../types';
+import type { SpanStorage } from '../../log-trace/types';
+/**
+ * Options for SpanDbReader
+ */
+export interface SpanDbReaderOptions {
+    /** Database path (for file-based SQLite) */
+    dbPath?: string;
+    /** Storage instance to use directly */
+    storage?: SpanStorage;
+}
+/**
+ * Span Database Reader
+ *
+ * Reads span data from SQLite storage for trace debugging and analysis.
+ */
+export declare class SpanDbReader {
+    private storage;
+    private dbPath;
+    private sqliteDb;
+    constructor(options?: SpanDbReaderOptions);
+    /**
+     * Initialize the reader with storage
+     */
+    initialize(): Promise<void>;
+    /**
+     * Initialize SQLite storage directly
+     */
+    private initSqliteStorage;
+    /**
+     * Get trace entries for a specific traceId
+     */
+    getTraceEntries(traceId: string): Promise<TraceEntry[]>;
+    /**
+     * List all trace IDs
+     */
+    listTraceIds(limit?: number): Promise<TraceSummary>;
+    /**
+     * Convert spans to TraceEntry format
+     *
+     * Now properly extracts spanId and parentSpanId for tree building
+     */
+    private spansToEntries;
+    /**
+     * Convert span attributes to params format
+     */
+    private attributesToParams;
+    /**
+     * Get the underlying storage
+     */
+    getStorage(): SpanStorage | null;
+    /**
+     * Close the reader and cleanup resources
+     */
+    close(): void;
+}
+/**
+ * Create a SpanDbReader from a database path
+ */
+export declare function createSpanDbReader(dbPath: string): Promise<SpanDbReader>;
+/**
+ * Create a SpanDbReader from an existing storage instance
+ */
+export declare function createSpanDbReaderFromStorage(storage: SpanStorage): SpanDbReader;
+//# sourceMappingURL=span-db-reader.d.ts.map

package/dist/core/src/env/debug/reader/span-db-reader.js

@@ -0,0 +1,167 @@
+/**
+ * @fileoverview Span DB Reader - Read spans from SQLite database
+ *
+ * This reader fetches trace data directly from SQLite span storage,
+ * which is used for persisting spans in production environments.
+ */
+/**
+ * Span Database Reader
+ *
+ * Reads span data from SQLite storage for trace debugging and analysis.
+ */
+export class SpanDbReader {
+    storage = null;
+    dbPath = null;
+    sqliteDb = null;
+    constructor(options) {
+        if (options?.storage) {
+            this.storage = options.storage;
+        }
+        else if (options?.dbPath) {
+            this.dbPath = options.dbPath;
+        }
+    }
+    /**
+     * Initialize the reader with storage
+     */
+    async initialize() {
+        if (this.storage) {
+            await this.storage.initialize();
+        }
+        else if (this.dbPath) {
+            // Lazy load SQLite storage
+            await this.initSqliteStorage();
+        }
+    }
+    /**
+     * Initialize SQLite storage directly
+     */
+    async initSqliteStorage() {
+        try {
+            // Dynamic import to avoid hard dependency
+            const { SQLiteSpanStorage } = await import('../../log-trace/span-storage');
+            this.storage = new SQLiteSpanStorage(this.dbPath);
+            await this.storage.initialize();
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize SQLite storage: ${error}`);
+        }
+    }
+    /**
+     * Get trace entries for a specific traceId
+     */
+    async getTraceEntries(traceId) {
+        if (!this.storage) {
+            throw new Error('Storage not initialized. Call initialize() first.');
+        }
+        const spans = this.storage.findByTraceId(traceId);
+        if (spans.length === 0) {
+            return [];
+        }
+        // Convert spans to TraceEntry format
+        return this.spansToEntries(spans);
+    }
+    /**
+     * List all trace IDs
+     */
+    async listTraceIds(limit = 20) {
+        if (!this.storage) {
+            throw new Error('Storage not initialized. Call initialize() first.');
+        }
+        const traceInfos = this.storage.listTraces(limit);
+        const traceIds = traceInfos.map(info => ({
+            traceId: info.traceId,
+            firstTime: new Date(info.startTime).toISOString(),
+            lastTime: info.endTime ? new Date(info.endTime).toISOString() : undefined,
+            count: info.spanCount,
+        }));
+        return {
+            traceIds,
+            count: traceInfos.length,
+        };
+    }
+    /**
+     * Convert spans to TraceEntry format
+     *
+     * Now properly extracts spanId and parentSpanId for tree building
+     */
+    spansToEntries(spans) {
+        const entries = [];
+        // Create entries for each span (enter event)
+        for (const span of spans) {
+            entries.push({
+                traceId: span.traceId,
+                timestamp: new Date(span.startTime).toISOString(),
+                function: span.name,
+                action: 'enter',
+                params: this.attributesToParams(span.attributes),
+                spanId: span.spanId,
+                parentSpanId: span.parentSpanId,
+            });
+            if (span.endTime) {
+                entries.push({
+                    traceId: span.traceId,
+                    timestamp: new Date(span.endTime).toISOString(),
+                    function: span.name,
+                    action: 'quit',
+                    result: span.result,
+                    error: span.error,
+                    durationMs: span.endTime - span.startTime,
+                    spanId: span.spanId,
+                    parentSpanId: span.parentSpanId,
+                });
+            }
+        }
+        // Sort by timestamp
+        entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        return entries;
+    }
+    /**
+     * Convert span attributes to params format
+     */
+    attributesToParams(attributes) {
+        if (!attributes)
+            return [];
+        return Object.entries(attributes).map(([key, value]) => ({
+            key,
+            value,
+        }));
+    }
+    /**
+     * Get the underlying storage
+     */
+    getStorage() {
+        return this.storage;
+    }
+    /**
+     * Close the reader and cleanup resources
+     */
+    close() {
+        if (this.storage) {
+            this.storage.close();
+            this.storage = null;
+        }
+        if (this.sqliteDb) {
+            this.sqliteDb.close();
+            this.sqliteDb = null;
+        }
+    }
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Create a SpanDbReader from a database path
+ */
+export async function createSpanDbReader(dbPath) {
+    const reader = new SpanDbReader({ dbPath });
+    await reader.initialize();
+    return reader;
+}
+/**
+ * Create a SpanDbReader from an existing storage instance
+ */
+export function createSpanDbReaderFromStorage(storage) {
+    return new SpanDbReader({ storage });
+}
+//# sourceMappingURL=span-db-reader.js.map

package/dist/core/src/env/debug/reader/span-db-reader.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview SpanDbReader Test
+ */
+export {};
+//# sourceMappingURL=span-db-reader.test.d.ts.map

package/dist/core/src/env/debug/reader/span-db-reader.test.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview SpanDbReader Test
+ */
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { SpanDbReader } from "./span-db-reader.js";
+import { SQLiteSpanStorage } from "../../log-trace/span-storage.js";
+import { SpanKind, SpanStatus } from "../../log-trace/types.js";
+import * as fs from 'fs';
+// Test data
+const testSpan1 = {
+    traceId: 'trace_test_001',
+    spanId: 'span_1',
+    name: 'testFunction',
+    kind: SpanKind.INTERNAL,
+    status: SpanStatus.OK,
+    startTime: Date.now() - 1000,
+    endTime: Date.now(),
+    attributes: { arg1: 'value1', arg2: 123 },
+    children: [],
+};
+const testSpan2 = {
+    traceId: 'trace_test_002',
+    spanId: 'span_2',
+    name: 'anotherFunction',
+    kind: SpanKind.INTERNAL,
+    status: SpanStatus.OK,
+    startTime: Date.now() - 500,
+    endTime: Date.now() - 100,
+    attributes: {},
+    children: [],
+};
+describe('SpanDbReader', () => {
+    let storage;
+    let reader;
+    let tempDbPath;
+    beforeAll(async () => {
+        // 清除环境变量中的 trace context，避免继承外部上下文
+        delete process.env['TRACEPARENT'];
+        delete process.env['TRACE_ID'];
+        delete process.env['LOG_TRACE_REQUEST_ID'];
+        // Create temporary database file
+        tempDbPath = `/tmp/test_span_db_${Date.now()}.sqlite`;
+        storage = new SQLiteSpanStorage(tempDbPath);
+        await storage.initialize();
+        // Insert test data
+        storage.save(testSpan1);
+        storage.save(testSpan2);
+        // Create reader with storage
+        reader = new SpanDbReader({ storage });
+    });
+    afterAll(() => {
+        reader.close();
+        storage.close();
+        // Cleanup temp file
+        if (fs.existsSync(tempDbPath)) {
+            fs.unlinkSync(tempDbPath);
+        }
+    });
+    test('should list trace IDs', async () => {
+        const summary = await reader.listTraceIds(10);
+        expect(summary.count).toBeGreaterThanOrEqual(2);
+        expect(summary.traceIds.length).toBeGreaterThanOrEqual(2);
+        const traceIds = summary.traceIds.map(t => t.traceId);
+        expect(traceIds).toContain('trace_test_001');
+        expect(traceIds).toContain('trace_test_002');
+    });
+    test('should get trace entries by traceId', async () => {
+        const entries = await reader.getTraceEntries('trace_test_001');
+        expect(entries.length).toBeGreaterThanOrEqual(2); // enter and quit
+        expect(entries[0].traceId).toBe('trace_test_001');
+        expect(entries[0].function).toBe('testFunction');
+        expect(entries[0].action).toBe('enter');
+    });
+    test('should return empty array for non-existent trace', async () => {
+        const entries = await reader.getTraceEntries('non_existent_trace');
+        expect(entries).toHaveLength(0);
+    });
+    test('should limit trace list', async () => {
+        const summary = await reader.listTraceIds(1);
+        expect(summary.traceIds.length).toBeLessThanOrEqual(1);
+    });
+});
+describe('SpanDbReader with dbPath', () => {
+    test('should initialize from dbPath', async () => {
+        const tempPath = `/tmp/test_span_db_${Date.now()}.sqlite`;
+        const reader = new SpanDbReader({ dbPath: tempPath });
+        await reader.initialize();
+        expect(reader.getStorage()).toBeTruthy();
+        reader.close();
+        // Cleanup
+        if (fs.existsSync(tempPath)) {
+            fs.unlinkSync(tempPath);
+        }
+    });
+});
+//# sourceMappingURL=span-db-reader.test.js.map