numux 0.0.1 → 1.1.0

package/src/utils/logger.ts

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,53 @@
+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 = []
+	}
+}