numux 1.4.0 → 1.5.1

package/src/utils/log-writer.ts

@@ -1,48 +0,0 @@
-import { closeSync, mkdirSync, openSync, writeSync } from 'node:fs'
-import { join } from 'node:path'
-import type { ProcessEvent } from '../types'
-import { stripAnsi } from './color'
-
-/** Writes process output to per-process log files in the given directory. */
-export class LogWriter {
-	private dir: string
-	private files = new Map<string, number>()
-	private decoder = new TextDecoder()
-	private encoder = new TextEncoder()
-
-	constructor(dir: string) {
-		this.dir = dir
-		mkdirSync(dir, { recursive: true })
-	}
-
-	private errored = false
-
-	/** Event listener — pass to ProcessManager.on() */
-	handleEvent = (event: ProcessEvent): void => {
-		if (event.type !== 'output' || this.errored) return
-
-		try {
-			let fd = this.files.get(event.name)
-			if (fd === undefined) {
-				const path = join(this.dir, `${event.name}.log`)
-				fd = openSync(path, 'w')
-				this.files.set(event.name, fd)
-			}
-
-			const text = this.decoder.decode(event.data, { stream: true })
-			const clean = stripAnsi(text)
-			writeSync(fd, this.encoder.encode(clean))
-		} catch {
-			// Disk full, permissions, deleted dir — warn once and stop writing
-			this.errored = true
-			process.stderr.write(`numux: log writing failed for ${this.dir}, disabling log output\n`)
-		}
-	}
-
-	close(): void {
-		for (const fd of this.files.values()) {
-			closeSync(fd)
-		}
-		this.files.clear()
-	}
-}

package/src/utils/logger.ts

@@ -1,32 +0,0 @@
-import { appendFileSync, existsSync, mkdirSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-let enabled = false
-let logFile = ''
-
-export function enableDebugLog(dir?: string): void {
-	const logDir = dir ?? resolve(process.cwd(), '.numux')
-	logFile = resolve(logDir, 'debug.log')
-	if (!existsSync(logDir)) {
-		mkdirSync(logDir, { recursive: true })
-	}
-	enabled = true
-}
-
-export function log(message: string, ...args: unknown[]): void {
-	if (!enabled) return
-	try {
-		const timestamp = new Date().toISOString()
-		const formatted = args.length > 0 ? `${message} ${args.map(a => JSON.stringify(a)).join(' ')}` : message
-		appendFileSync(logFile, `[${timestamp}] ${formatted}\n`)
-	} catch {
-		// Disk errors in debug logging should not crash the app
-		enabled = false
-	}
-}
-
-/** Reset logger state (for testing only) */
-export function _resetLogger(): void {
-	enabled = false
-	logFile = ''
-}

package/src/utils/shutdown.ts

@@ -1,39 +0,0 @@
-import type { App } from '../ui/app'
-import type { LogWriter } from './log-writer'
-import { log } from './logger'
-
-export function setupShutdownHandlers(app: App, logWriter?: LogWriter): void {
-	let shuttingDown = false
-
-	const shutdown = () => {
-		if (shuttingDown) {
-			process.exit(1)
-		}
-		shuttingDown = true
-		app.shutdown().finally(() => {
-			logWriter?.close()
-			process.exit(app.hasFailures() ? 1 : 0)
-		})
-	}
-
-	process.on('SIGINT', shutdown)
-	process.on('SIGTERM', shutdown)
-	process.on('uncaughtException', err => {
-		log('Uncaught exception:', err?.message ?? err)
-		process.stderr.write(`numux: unexpected error: ${err?.stack ?? err}\n`)
-		app.shutdown().finally(() => {
-			logWriter?.close()
-			process.exit(1)
-		})
-	})
-
-	process.on('unhandledRejection', (reason: unknown) => {
-		const message = reason instanceof Error ? reason.message : String(reason)
-		log('Unhandled rejection:', message)
-		process.stderr.write(`numux: unhandled rejection: ${message}\n`)
-		app.shutdown().finally(() => {
-			logWriter?.close()
-			process.exit(1)
-		})
-	})
-}

package/src/utils/watcher.ts

@@ -1,53 +0,0 @@
-import { type FSWatcher, watch } from 'node:fs'
-import { log } from './logger'
-
-const DEBOUNCE_MS = 300
-const IGNORED_SEGMENTS = new Set(['node_modules', '.git'])
-
-export class FileWatcher {
-	private watchers: FSWatcher[] = []
-	private debounceTimers = new Map<string, ReturnType<typeof setTimeout>>()
-
-	watch(name: string, patterns: string[], cwd: string, onChanged: (path: string) => void): void {
-		const globs = patterns.map(p => new Bun.Glob(p))
-
-		try {
-			const watcher = watch(cwd, { recursive: true }, (_event, filename) => {
-				if (!filename) return
-
-				// Skip node_modules, .git, etc.
-				const segments = filename.split('/')
-				if (segments.some(s => IGNORED_SEGMENTS.has(s))) return
-
-				// Check if changed file matches any pattern
-				if (!globs.some(g => g.match(filename))) return
-
-				// Debounce per process
-				const existing = this.debounceTimers.get(name)
-				if (existing) clearTimeout(existing)
-				this.debounceTimers.set(
-					name,
-					setTimeout(() => {
-						this.debounceTimers.delete(name)
-						onChanged(filename)
-					}, DEBOUNCE_MS)
-				)
-			})
-			this.watchers.push(watcher)
-			log(`[${name}] Watching: ${patterns.join(', ')}`)
-		} catch (err) {
-			log(`[${name}] Failed to set up file watcher: ${err}`)
-		}
-	}
-
-	close(): void {
-		for (const timer of this.debounceTimers.values()) {
-			clearTimeout(timer)
-		}
-		this.debounceTimers.clear()
-		for (const watcher of this.watchers) {
-			watcher.close()
-		}
-		this.watchers = []
-	}
-}