diff --git a/packages/plugin/src/host-log-store.ts b/packages/plugin/src/host-log-store.ts new file mode 100644 index 0000000..703c6e5 --- /dev/null +++ b/packages/plugin/src/host-log-store.ts @@ -0,0 +1,338 @@ +import { mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises' +import { homedir } from 'node:os' +import { dirname, join } from 'node:path' +import type { LogLevel } from './logging.js' + +export type PluginLogFilter = 'all' | 'warn' + +export interface PluginLogEntry { + seq: number + timestamp: string + level: LogLevel + line: string +} + +export interface HostLogReadOptions { + filter?: PluginLogFilter + limit?: number +} + +export interface HostLogSnapshot { + entries: PluginLogEntry[] + totalBuffered: number + filePath?: string + fileError?: string +} + +export interface HostLogStoreOptions { + filePath?: string + maxEntries?: number + maxFileBytes?: number + maxBackups?: number +} + +export interface ResolveHostLogPathOptions { + env?: NodeJS.ProcessEnv + homeDirectory?: string + profile?: string +} + +const DEFAULT_MAX_ENTRIES = 1000 +const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024 +const DEFAULT_MAX_BACKUPS = 2 +const MAX_LINE_CHARS = 8192 +const TAIL_READ_BYTES = 512 * 1024 + +export function resolveHostLogPath(options: ResolveHostLogPathOptions = {}): string { + const env = options.env ?? process.env + const home = env.DSH_HOME || join(options.homeDirectory ?? homedir(), '.dsh') + const rawProfile = options.profile ?? env.DSH_PROFILE ?? '' + const profileSlug = rawProfile + .trim() + .replace(/[^a-zA-Z0-9_-]+/g, '-') + .replace(/^-+|-+$/g, '') || 'host' + return join(home, 'logs', 'ds-harness-remote', `${profileSlug}.log`) +} + +export class HostLogStore { + readonly filePath?: string + private readonly maxEntries: number + private readonly maxFileBytes: number + private readonly maxBackups: number + private liveEntries: PluginLogEntry[] = [] + private persistedEntries: PluginLogEntry[] = [] + private nextSeq = 1 + private currentBytes = 0 + private fileError?: string + private writeChain: Promise = Promise.resolve() + private readonly initPromise: Promise + private clearedBeforeInit = false + private sizeVerified = false + private dirEnsured = false + private pendingDiskLines: string[] = [] + private diskFlushScheduled = false + + constructor(options: HostLogStoreOptions = {}) { + this.filePath = options.filePath + this.maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_ENTRIES) + this.maxFileBytes = Math.max(1024, options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES) + this.maxBackups = Math.max(0, options.maxBackups ?? DEFAULT_MAX_BACKUPS) + this.initPromise = this.loadInitialFile() + this.writeChain = this.initPromise.catch(() => undefined) + } + + record(level: LogLevel, message: string, now: Date = new Date()): void { + const timestamp = now.toISOString() + const clean = sanitizeLogMessage(message) + const line = `${timestamp} [${level.toUpperCase()}] ${clean}` + const entry: PluginLogEntry = { + seq: this.nextSeq++, + timestamp, + level, + line, + } + this.liveEntries.push(entry) + this.trimInMemory() + + if (this.filePath !== undefined) { + this.pendingDiskLines.push(`${line}\n`) + this.scheduleDiskFlush() + } + } + + async snapshot(options: HostLogReadOptions = {}): Promise { + await this.initPromise.catch(() => undefined) + const filter = options.filter ?? 'all' + const limit = Math.min(this.maxEntries, Math.max(1, options.limit ?? 500)) + const combined = this.combinedEntries() + const filtered = filter === 'warn' + ? combined.filter(entry => entry.level === 'warn' || entry.level === 'error') + : combined + const entries = filtered.length > limit ? filtered.slice(-limit) : filtered + return { + entries, + totalBuffered: combined.length, + ...(this.filePath === undefined ? {} : { filePath: this.filePath }), + ...(this.fileError === undefined ? {} : { fileError: this.fileError }), + } + } + + async clear(): Promise { + this.clearedBeforeInit = true + this.persistedEntries = [] + this.liveEntries = [] + this.pendingDiskLines = [] + if (this.filePath !== undefined) { + this.enqueueWrite(async () => { + await this.clearDisk() + }) + await this.writeChain + } + const entries = this.combinedEntries() + return { + entries, + totalBuffered: entries.length, + ...(this.filePath === undefined ? {} : { filePath: this.filePath }), + ...(this.fileError === undefined ? {} : { fileError: this.fileError }), + } + } + + async flush(): Promise { + await this.writeChain + } + + private scheduleDiskFlush(): void { + if (this.diskFlushScheduled) return + this.diskFlushScheduled = true + this.enqueueWrite(async () => { + while (this.pendingDiskLines.length > 0) { + let batch = '' + let batchBytes = 0 + while (this.pendingDiskLines.length > 0) { + const next = this.pendingDiskLines[0]! + const nextBytes = Buffer.byteLength(next, 'utf8') + if (batch.length > 0 && this.currentBytes + batchBytes + nextBytes > this.maxFileBytes) break + this.pendingDiskLines.shift() + batch += next + batchBytes += nextBytes + } + await this.appendToDisk(batch) + } + this.diskFlushScheduled = false + }, () => { + this.diskFlushScheduled = false + }) + } + + private enqueueWrite(task: () => Promise, onError?: () => void): void { + this.writeChain = this.writeChain.then(async () => { + try { + await task() + this.fileError = undefined + } catch (error) { + this.dirEnsured = false + onError?.() + this.fileError = safeFsErrorMessage(error) + } + }) + } + + private async loadInitialFile(): Promise { + if (this.filePath === undefined) return + try { + const info = await stat(this.filePath) + this.currentBytes = info.size + this.sizeVerified = true + if (this.clearedBeforeInit || info.size === 0) return + const text = await readTailUtf8(this.filePath, info.size, TAIL_READ_BYTES) + if (this.clearedBeforeInit) return + const lines = text.split(/\r?\n/).filter(line => line.length > 0) + const tail = lines.slice(-this.maxEntries) + const parsed: PluginLogEntry[] = [] + let seqBase = 1 + for (const line of tail) { + parsed.push(parsePersistedLine(line, seqBase++)) + } + this.persistedEntries = parsed + let next = parsed.length + 1 + for (const entry of this.liveEntries) { + entry.seq = next++ + } + this.nextSeq = next + this.trimInMemory() + } catch (error) { + if (isEnoent(error)) { + this.currentBytes = 0 + this.sizeVerified = true + return + } + this.fileError = safeFsErrorMessage(error) + } + } + + private async appendToDisk(payload: string): Promise { + const target = this.filePath! + if (!this.dirEnsured) { + await mkdir(dirname(target), { recursive: true, mode: 0o700 }) + this.dirEnsured = true + } + if (!this.sizeVerified) { + const existing = await stat(target).catch(err => (isEnoent(err) ? undefined : Promise.reject(err))) + this.currentBytes = existing?.size ?? 0 + this.sizeVerified = true + } + const byteLength = Buffer.byteLength(payload, 'utf8') + if (this.currentBytes > 0 && this.currentBytes + byteLength > this.maxFileBytes) { + await this.rotateFiles(target) + } + await writeFile(target, payload, { encoding: 'utf8', flag: 'a', mode: 0o600 }) + this.currentBytes += byteLength + } + + private async rotateFiles(target: string): Promise { + if (this.maxBackups === 0) { + await writeFile(target, '', { encoding: 'utf8', mode: 0o600 }) + this.currentBytes = 0 + return + } + for (let index = this.maxBackups; index >= 1; index--) { + const dest = `${target}.${index}` + const src = index === 1 ? target : `${target}.${index - 1}` + if (index === this.maxBackups) { + await rm(dest, { force: true }).catch(() => undefined) + } + try { + await rename(src, dest) + } catch (error) { + if (!isEnoent(error)) throw error + } + } + this.currentBytes = 0 + } + + private async clearDisk(): Promise { + const target = this.filePath! + if (!this.dirEnsured) { + await mkdir(dirname(target), { recursive: true, mode: 0o700 }) + this.dirEnsured = true + } + await writeFile(target, '', { encoding: 'utf8', mode: 0o600 }) + this.sizeVerified = true + for (let index = 1; index <= this.maxBackups; index++) { + await rm(`${target}.${index}`, { force: true }).catch(() => undefined) + } + this.currentBytes = 0 + } + + private combinedEntries(): PluginLogEntry[] { + if (this.persistedEntries.length === 0) return [...this.liveEntries] + const merged = [...this.persistedEntries, ...this.liveEntries] + return merged.length > this.maxEntries ? merged.slice(-this.maxEntries) : merged + } + + private trimInMemory(): void { + const total = this.persistedEntries.length + this.liveEntries.length + if (total <= this.maxEntries) return + const overflow = total - this.maxEntries + if (this.persistedEntries.length >= overflow) { + this.persistedEntries.splice(0, overflow) + } else { + const remaining = overflow - this.persistedEntries.length + this.persistedEntries = [] + this.liveEntries.splice(0, remaining) + } + } +} + +function sanitizeLogMessage(message: string): string { + const redacted = message + .replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, 'Bearer [REDACTED]') + .replace(/([?&](?:token|access_token|refresh_token|secret|password|authorization|cookie|code)=)[^&\s]+/gi, '$1[REDACTED]') + const collapsed = redacted.replace(/[\r\n]+/g, ' ').trimEnd() + if (collapsed.length <= MAX_LINE_CHARS) return collapsed + return `${collapsed.slice(0, MAX_LINE_CHARS)}...` +} + +function parsePersistedLine(line: string, seq: number): PluginLogEntry { + const match = line.match(/^(\d{4}-\d{2}-\d{2}T\S+)\s+\[(DEBUG|INFO|WARN|ERROR)\]\s+(.*)$/) + if (match === null) { + return { seq, timestamp: '', level: 'info', line } + } + const level = match[2]!.toLowerCase() as LogLevel + return { + seq, + timestamp: match[1]!, + level, + line, + } +} + +async function readTailUtf8(filePath: string, totalSize: number, maxBytes: number): Promise { + if (totalSize <= maxBytes) { + return readFile(filePath, 'utf8') + } + const handle = await open(filePath, 'r') + try { + const start = totalSize - maxBytes + const buffer = Buffer.allocUnsafe(maxBytes) + const { bytesRead } = await handle.read(buffer, 0, maxBytes, start) + const raw = buffer.subarray(0, bytesRead).toString('utf8') + const firstNewline = raw.indexOf('\n') + return firstNewline === -1 ? raw : raw.slice(firstNewline + 1) + } finally { + await handle.close() + } +} + +function isEnoent(error: unknown): boolean { + return typeof error === 'object' && error !== null && (error as { code?: unknown }).code === 'ENOENT' +} + +function safeFsErrorMessage(error: unknown): string { + if (error instanceof Error && error.message.trim().length > 0) { + const home = homedir() + const normalized = home.length > 0 ? error.message.split(home).join('~') : error.message + return normalized.replace(/[\r\n]+/g, ' ').trim() + } + return 'Failed to write log file.' +}