@24klynx/cli 0.1.0

package/dist/process-lifecycle-Dg6n2QS-.mjs

@@ -0,0 +1,784 @@
+import { n as loadConfig } from "./config-Des0z-k9.mjs";
+import { migrate, openDatabase, resolvePaths } from "@lynx/core";
+import { createSessionManager } from "@lynx/session";
+import { createMcpAuthHandler, createMemoryWriteHandler, createSendMessageHandler, createToolRegistry, injectTaskManager, mcpAuthDescriptor, memoryWriteDescriptor, registerBuiltinTools, sendMessageDescriptor } from "@lynx/tools";
+import { PredictiveLoader, createHookRegistry, createManifestRegistry, createPluginLoader } from "@lynx/plugins";
+import { createMcpManager, createMemoryManager, createQueryEngine, createSkillRegistry, createSkillToolHandler, createTaskManager, getBaseSystemPrompt } from "@lynx/agent";
+import { createDenialTracker, createRuleEngine, createRulesLoader, loadFromDisk } from "@lynx/permissions";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { createChannelRegistry, createFeishuAdapter } from "@lynx/channels";
+//#region src/mcp-loader.ts
+/**
+* MCP configuration loader — reads MCP server configurations
+* from Lynx settings files (3‑layer merge: global → project → local).
+*
+* Settings layers (later overrides earlier for same‑named servers):
+*   1. ~/.lynx/settings.json       — global
+*   2. .lynx/settings.json          — project (committed)
+*   3. .lynx/settings.local.json    — project local (gitignored)
+*/
+/**
+* Try to read and parse a JSON file. Returns undefined if the file
+* does not exist or is malformed.
+*/
+function tryReadJson(filePath) {
+	if (!existsSync(filePath)) return void 0;
+	try {
+		return JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch {
+		return;
+	}
+}
+/**
+* Find the project root by walking up from cwd looking for `.lynx/`.
+* Returns undefined if no project root is found.
+*/
+function findProjectRoot(startDir) {
+	let dir = startDir;
+	for (let i = 0; i < 50; i++) {
+		if (existsSync(join(dir, ".lynx"))) return dir;
+		const parent = join(dir, "..");
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+/**
+* Load MCP server configurations from all settings layers.
+*
+* Merge order: global → project → project‑local.
+* Same‑named servers in later layers override earlier ones entirely.
+*/
+function loadMcpConfigs(workspaceDir) {
+	const globalSettings = tryReadJson(resolvePaths().settingsFile);
+	const projectRoot = workspaceDir ? findProjectRoot(workspaceDir) : findProjectRoot(process.cwd());
+	const projectSettings = projectRoot ? tryReadJson(join(projectRoot, ".lynx", "settings.json")) : void 0;
+	const localSettings = projectRoot ? tryReadJson(join(projectRoot, ".lynx", "settings.local.json")) : void 0;
+	const merged = /* @__PURE__ */ new Map();
+	function addServers(servers, source) {
+		if (!servers) return;
+		for (const server of servers) merged.set(server.name, {
+			config: server,
+			source
+		});
+	}
+	addServers(globalSettings?.mcpServers, "global");
+	addServers(projectSettings?.mcpServers, "project");
+	addServers(localSettings?.mcpServers, "project-local");
+	return {
+		servers: Array.from(merged.values()).map((e) => e.config),
+		entries: merged
+	};
+}
+/**
+* Convenience: load and validate MCP configs for bootstrap.
+*
+* Returns an array of valid McpServerConfig objects, filtering out
+* entries that have neither a `command` nor a `url`.
+*/
+function loadAndValidateMcpConfigs(workspaceDir) {
+	return loadMcpConfigs(workspaceDir).servers.filter((s) => {
+		const isValid = !!(s.command || s.url);
+		if (!isValid) {}
+		return isValid;
+	});
+}
+//#endregion
+//#region src/bootstrap.ts
+/** Timeout for auto‑denying a permission request when the user doesn't respond. */
+const PERMISSION_TIMEOUT_MS = 6e4;
+/**
+* Create a permission bridge that mediates between the agent engine
+* and the TUI's permission dialog.
+*
+* The bridge uses a Promise Map pattern:
+*   1. Agent calls `requestPermission()` → Promise created + stored
+*   2. TUI handler fires → shows permission dialog
+*   3. User responds → `handleReply()` resolves the Promise
+*   4. Agent resumes (or skips the tool)
+*
+* Safety levels "Safe" and "WorkspaceSafe" are auto‑allowed without
+* showing the dialog.
+*/
+function createPermissionBridge() {
+	const pending = /* @__PURE__ */ new Map();
+	let tuiHandler = null;
+	return {
+		async requestPermission(toolName, safety, description) {
+			if (safety === "Safe" || safety === "WorkspaceSafe") return true;
+			return new Promise((resolve) => {
+				const requestId = randomUUID();
+				const timer = setTimeout(() => {
+					pending.delete(requestId);
+					resolve(false);
+				}, PERMISSION_TIMEOUT_MS);
+				pending.set(requestId, {
+					resolve,
+					timer
+				});
+				if (tuiHandler) tuiHandler({
+					requestId,
+					toolName,
+					description,
+					safety
+				});
+				else {
+					clearTimeout(timer);
+					pending.delete(requestId);
+					resolve(false);
+				}
+			});
+		},
+		handleReply(requestId, approved) {
+			const entry = pending.get(requestId);
+			if (entry) {
+				clearTimeout(entry.timer);
+				pending.delete(requestId);
+				entry.resolve(approved);
+			}
+		},
+		setTuiHandler(handler) {
+			tuiHandler = handler;
+		}
+	};
+}
+/**
+* Load all .md files from a directory as an array of file contents.
+* Silently returns [] if the directory doesn't exist or is unreadable.
+*/
+function loadTextFilesFromDir(dir) {
+	const facts = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return facts;
+	}
+	for (const entry of entries) {
+		if (!entry.endsWith(".md")) continue;
+		const fullPath = join(dir, entry);
+		try {
+			if (!statSync(fullPath).isFile()) continue;
+			facts.push(readFileSync(fullPath, "utf-8"));
+		} catch {}
+	}
+	return facts;
+}
+/**
+* Bootstrap the entire Lynx application.
+*
+* This is the ONLY place where cross‑package wiring happens.
+* Every other module only talks to its immediate dependencies
+* through explicit factory‑injected interfaces.
+*/
+function bootstrap(config) {
+	const dbPath = join(config.homeDir, "state.db");
+	const workspace = config.workspace ?? process.cwd();
+	const db = openDatabase({ dbPath });
+	migrate(db);
+	const sessionMgr = createSessionManager(db);
+	const toolRegistry = createToolRegistry();
+	const ruleEngine = createRuleEngine();
+	const rulesLoader = createRulesLoader(ruleEngine);
+	registerBuiltinTools(toolRegistry);
+	const skillRegistry = createSkillRegistry(config.skillsDir ?? join(config.homeDir, "..", "packages", "lynx-agent", "skills"));
+	const userSkillsDir = join(homedir(), ".lynx", "skills");
+	skillRegistry.addDirectory(userSkillsDir);
+	const projectSkillsDir = join(workspace, ".claude", "skills");
+	skillRegistry.addDirectory(projectSkillsDir);
+	const skills = skillRegistry.list();
+	toolRegistry.register({
+		name: "Skill",
+		description: "加载技能完整指令。支持 load（加载技能内容）、list（列出所有技能）、search（搜索技能）、reload（重新加载技能目录）四种操作。",
+		inputSchema: {
+			type: "object",
+			properties: {
+				action: {
+					type: "string",
+					enum: [
+						"load",
+						"list",
+						"search",
+						"reload"
+					],
+					description: "操作类型：load 加载技能内容、list 列出所有技能、search 搜索技能、reload 重新加载"
+				},
+				skill: {
+					type: "string",
+					description: "要加载的技能名称（load 操作时使用）"
+				},
+				args: {
+					type: "string",
+					description: "传递给技能的可选参数"
+				},
+				query: {
+					type: "string",
+					description: "搜索关键词（search 操作时使用）"
+				}
+			}
+		},
+		kind: "ReadOnly",
+		safety: "Safe",
+		availability: { type: "always" },
+		executor: "Skill",
+		owner: "core"
+	}, createSkillToolHandler(skillRegistry));
+	const mcpManager = createMcpManager();
+	const settingsMcpServers = loadAndValidateMcpConfigs();
+	const programmaticServers = config.mcpServers ?? [];
+	const settingsOnly = settingsMcpServers.filter((s) => !programmaticServers.some((p) => p.name === s.name));
+	const allMcpServers = [...programmaticServers, ...settingsOnly];
+	for (const serverConfig of allMcpServers) mcpManager.connect(serverConfig).catch(() => {});
+	const channelRegistry = createChannelRegistry();
+	if (config.feishu?.appId && config.feishu?.appSecret) {
+		const feishuAdapter = createFeishuAdapter(config.feishu);
+		channelRegistry.register(feishuAdapter);
+	}
+	const toolHandlers = /* @__PURE__ */ new Map();
+	const allTools = toolRegistry.listAll();
+	for (const desc of allTools) try {
+		const handler = toolRegistry.resolveExecutor(desc);
+		toolHandlers.set(desc.name, handler);
+	} catch {}
+	const mcpDispatcher = { async handle(invocation, _signal) {
+		const result = await mcpManager.callTool(invocation.toolName, invocation.payload);
+		return {
+			content: result.content,
+			success: !result.isError
+		};
+	} };
+	for (const mcpTool of mcpManager.getAllTools()) {
+		if (toolHandlers.has(mcpTool.name)) {
+			process.stderr.write(`[lynx] 警告：MCP 工具 "${mcpTool.name}" 与现有工具冲突 — 已跳过\n`);
+			continue;
+		}
+		toolHandlers.set(mcpTool.name, mcpDispatcher);
+	}
+	new Set(mcpManager.getAllTools().map((t) => t.name));
+	const allToolsWithMcp = [...allTools, ...mcpManager.getAllTools().filter((t) => !allTools.some((b) => b.name === t.name))];
+	const manifestRegistry = createManifestRegistry();
+	const hookRegistry = createHookRegistry();
+	const pluginRegistry = {
+		manifestRegistry,
+		loader: createPluginLoader(),
+		hooks: hookRegistry
+	};
+	const predictiveLoader = new PredictiveLoader(async (pluginId) => {
+		return import(pluginId);
+	});
+	loadFromDisk(rulesLoader, workspace);
+	const denialTracker = createDenialTracker();
+	const permissionBridge = createPermissionBridge();
+	const userMemoryDir = join(homedir(), ".lynx", "memory");
+	const projectMemoryDir = join(workspace, ".claude", "memory");
+	const memoryManager = createMemoryManager(userMemoryDir);
+	const memoryFacts = [...memoryManager.list().map((e) => memoryManager.get(e.name)?.content).filter(Boolean), ...loadTextFilesFromDir(projectMemoryDir)];
+	const memoryWriteHandler = createMemoryWriteHandler(memoryManager);
+	toolRegistry.register(memoryWriteDescriptor, memoryWriteHandler);
+	toolHandlers.set(memoryWriteDescriptor.name, memoryWriteHandler);
+	allTools.push(memoryWriteDescriptor);
+	const mcpAuthHandler = createMcpAuthHandler({ reconnect: async (serverName) => {
+		return { status: (await mcpManager.reconnect(serverName)).status };
+	} });
+	toolRegistry.register(mcpAuthDescriptor, mcpAuthHandler);
+	toolHandlers.set(mcpAuthDescriptor.name, mcpAuthHandler);
+	allTools.push(mcpAuthDescriptor);
+	const sendMessageHandler = createSendMessageHandler({ async send(channel, content, recipients) {
+		const adapter = channelRegistry.get(channel);
+		if (!adapter) throw new Error(`未注册的消息通道：${channel}`);
+		const message = {
+			id: randomUUID(),
+			role: "assistant",
+			content: [{
+				type: "text",
+				text: content
+			}],
+			timestamp: Date.now(),
+			turnIndex: 0
+		};
+		return { messageId: await adapter.sendMessage(message) };
+	} });
+	toolRegistry.register(sendMessageDescriptor, sendMessageHandler);
+	toolHandlers.set(sendMessageDescriptor.name, sendMessageHandler);
+	allTools.push(sendMessageDescriptor);
+	const globalLynxMd = join(homedir(), ".lynx", "LYNX.md");
+	const globalInstructions = [];
+	try {
+		if (existsSync(globalLynxMd) && statSync(globalLynxMd).isFile()) globalInstructions.push(`# LYNX.md — 全局用户指令\n${readFileSync(globalLynxMd, "utf-8")}`);
+	} catch {}
+	const userRulesDir = join(homedir(), ".lynx", "rules");
+	const projectRulesDir = join(workspace, ".claude", "rules");
+	const rules = [
+		...globalInstructions,
+		...loadTextFilesFromDir(userRulesDir),
+		...loadTextFilesFromDir(projectRulesDir)
+	];
+	const agentConfig = {
+		provider: config.provider,
+		model: config.model,
+		systemPrompt: getBaseSystemPrompt(),
+		maxTokens: 8192,
+		maxCompactionFailures: 3,
+		budget: {
+			maxTokens: 2e5,
+			maxUsd: 10,
+			maxTurns: 100
+		}
+	};
+	const engine = createQueryEngine({
+		config: agentConfig,
+		provider: config.provider,
+		toolHandlers,
+		allTools: allToolsWithMcp,
+		skills,
+		memoryFacts,
+		rules,
+		checkPermission: async (toolName, safety, description) => {
+			if (denialTracker.isTripped()) return false;
+			const safetyLevel = safety;
+			const approved = await permissionBridge.requestPermission(toolName, safetyLevel, description);
+			if (safetyLevel === "RequiresApproval" || safetyLevel === "Dangerous") if (approved) denialTracker.recordApproval();
+			else denialTracker.recordDenial();
+			return approved;
+		}
+	});
+	const taskManager = createTaskManager();
+	injectTaskManager(taskManager);
+	return {
+		db,
+		sessionMgr,
+		toolRegistry,
+		pluginRegistry,
+		ruleEngine,
+		engine,
+		provider: config.provider,
+		agentConfig,
+		permissionBridge,
+		skillRegistry,
+		skills,
+		mcpManager,
+		predictiveLoader,
+		channelRegistry,
+		memoryManager,
+		memoryFacts,
+		rules,
+		destroy() {
+			taskManager.destroy();
+			channelRegistry.destroyAll();
+			mcpManager.destroy();
+			engine.destroy();
+			sessionMgr.destroy();
+			db.close();
+		}
+	};
+}
+//#endregion
+//#region src/startup.ts
+/**
+* Run Phase 1 — blocking startup that must finish before
+* the user sees anything useful.
+*
+* Returns a database handle the rest of the app can use.
+*/
+function runPhase1() {
+	const started = Date.now();
+	const paths = resolvePaths();
+	const db = openDatabase({ dbPath: paths.stateDb });
+	migrate(db);
+	return {
+		paths,
+		db,
+		elapsedMs: Date.now() - started
+	};
+}
+/**
+* Run Phase 2 — background work that executes after the TUI is rendered.
+*
+* Tasks run sequentially with a setImmediate gap between each so the
+* event loop stays responsive. Each task is independently try‑catched
+* so a single failure doesn't block the rest.
+*
+* Returns the elapsed time in ms.
+*/
+async function runPhase2(result) {
+	return runPhase2Tasks(null, result.paths);
+}
+/**
+* Run Phase 2 with the full AppContext (preferred path).
+*
+* When called from the TUI launcher, the AppContext provides access
+* to all initialized services (plugin registry, MCP manager, etc.).
+*
+* Tasks:
+*   1. scanExtensions — discover plugins in the extensions directory
+*   2. preloadSkills — index skills for autocomplete
+*   3. connectMcpServers — establish MCP connections
+*   4. loadMemory — load memory files into the agent context
+*/
+async function runPhase2WithContext(ctx, paths) {
+	return runPhase2Tasks(ctx, paths);
+}
+function createSilentLogger() {
+	return {
+		info: () => {},
+		warn: (msg) => process.stderr.write(`[phase2] ${msg}\n`)
+	};
+}
+async function runPhase2Tasks(ctx, paths) {
+	const logger = createSilentLogger();
+	const results = [];
+	const tasks = [
+		async () => {
+			await scanExtensions(ctx, paths, logger);
+		},
+		async () => {
+			await preloadSkills(ctx, paths, logger);
+		},
+		async () => {
+			await connectMcpServers(ctx, logger);
+		},
+		async () => {
+			await loadMemory(ctx, paths, logger);
+		},
+		async () => {
+			await initChannels(ctx, logger);
+		}
+	];
+	for (const task of tasks) {
+		await new Promise((resolve) => setImmediate(resolve));
+		const started = Date.now();
+		const name = task.name || "unknown";
+		try {
+			await task();
+			results.push({
+				name,
+				ok: true,
+				elapsedMs: Date.now() - started
+			});
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logger.warn(`${name} failed: ${message}`);
+			results.push({
+				name,
+				ok: false,
+				error: message,
+				elapsedMs: Date.now() - started
+			});
+		}
+	}
+	if (results.some((r) => !r.ok)) {
+		const failures = results.filter((r) => !r.ok).map((r) => r.name).join(", ");
+		logger.warn(`Phase 2 completed with failures: ${failures}`);
+	} else logger.info(`Phase 2 completed: ${results.length} tasks OK`);
+	return results;
+}
+/**
+* Scan the extensions directory for plugins, register manifests,
+* and execute plugin code via the PluginLoader.
+*
+* Looks in:
+*   1. <lynx-home>/extensions/ (user extensions)
+*   2. <project>/.lynx/extensions/ (project extensions)
+*   3. <lynx-install>/extensions/ (built‑in extensions)
+*/
+async function scanExtensions(ctx, paths, logger) {
+	if (!ctx) return;
+	const { readdirSync, statSync } = await import("node:fs");
+	const { join } = await import("node:path");
+	const scanDirs = [join(paths.home, "extensions"), join(process.cwd(), ".lynx", "extensions")];
+	for (const dir of scanDirs) {
+		let entries;
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const fullPath = join(dir, entry);
+			try {
+				if (!statSync(fullPath).isDirectory()) continue;
+			} catch {
+				continue;
+			}
+			const manifestPath = join(fullPath, "manifest.json");
+			try {
+				statSync(manifestPath);
+			} catch {
+				continue;
+			}
+			try {
+				const discovered = ctx.pluginRegistry.manifestRegistry.scan([fullPath]);
+				for (const manifestEntry of discovered) {
+					const pluginCtx = {
+						pluginId: manifestEntry.manifest.name,
+						logger: {
+							info: (msg) => logger.info(`[plugin:${manifestEntry.manifest.name}] ${msg}`),
+							warn: (msg) => logger.warn(`[plugin:${manifestEntry.manifest.name}] ${msg}`),
+							error: (msg) => logger.warn(`[plugin:${manifestEntry.manifest.name}] ${msg}`)
+						},
+						config: {},
+						storage: createPluginStorage()
+					};
+					ctx.pluginRegistry.loader.load(manifestEntry, pluginCtx).catch((err) => {
+						logger.warn(`Plugin "${manifestEntry.manifest.name}" failed to load: ${String(err)}`);
+					});
+				}
+			} catch {}
+		}
+	}
+}
+/**
+* Create a simple in‑memory KV store for plugin storage.
+*
+* In Phase 5 this will be backed by the SQLite database
+* for persistence across sessions.
+*/
+function createPluginStorage() {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		get(key) {
+			return store.get(key);
+		},
+		set(key, value) {
+			store.set(key, value);
+		},
+		delete(key) {
+			store.delete(key);
+		},
+		clear() {
+			store.clear();
+		}
+	};
+}
+/**
+* Preload skill definitions for autocomplete and quick access.
+*
+* Skills are already loaded during bootstrap (Phase 1). This Phase 2 task
+* enqueues plugins for predictive warming through the PredictiveLoader,
+* reducing first‑use latency for plugins that are likely to be needed.
+*/
+async function preloadSkills(ctx, _paths, _logger) {
+	if (!ctx) return;
+	const loader = ctx.predictiveLoader;
+	loader.onInputPrefix("/");
+	loader.onInputPrefix("@");
+	await loader.processQueue();
+}
+/**
+* Connect to configured MCP servers.
+*
+* MCP connections are established during bootstrap (Phase 1) via
+* McpManager.connect() for all configured servers. Connection
+* failures are tracked via McpConnection.status.
+*
+* This Phase 2 task exists as a hook point for re‑connection or
+* health check logic in future phases.
+*/
+async function connectMcpServers(_ctx, _logger) {}
+/**
+* Load memory files into the agent's context.
+*
+* Memory is loaded during bootstrap (Phase 1) from:
+*   1. ~/.lynx/memory/
+*   2. <workspace>/.claude/memory/
+*
+* Content flows through AppContext.memoryFacts → EngineDeps →
+* LoopDeps → assembleSystemPrompt ("Memory" section).
+*
+* This Phase 2 task exists as a hook point for runtime memory
+* reload (e.g. after file changes).
+*/
+async function loadMemory(_ctx, paths, _logger) {}
+/**
+* Initialize registered channel adapters (飞书 etc.).
+*
+* Channels are registered during bootstrap (Phase 1) but their
+* init() (auth, WS connect) is deferred to Phase 2 so the TUI
+* is already visible before network I/O starts.
+*/
+async function initChannels(ctx, logger) {
+	if (!ctx) return;
+	const channelIds = ctx.channelRegistry.list();
+	if (channelIds.length === 0) {
+		logger.info("No channel adapters registered — skipping channel init");
+		return;
+	}
+	logger.info(`Initializing channels: ${channelIds.join(", ")}`);
+	await ctx.channelRegistry.initAll();
+	logger.info(`Channels initialized: ${channelIds.join(", ")}`);
+}
+//#endregion
+//#region src/terminal-mode.ts
+/**
+* Terminal mode management — alt buffer, mouse tracking, DEC sync.
+*
+* Provides functions to enter/exit the alternate screen buffer,
+* enable/disable mouse tracking, and wrap output with DEC
+* Synchronized Update markers for flicker‑free rendering.
+*
+* All escape sequences are no‑ops on unsupported terminals
+* (graceful degradation).
+*/
+/** Enter alternate screen buffer. */
+const ALT_ENTER = "\x1B[?1049h";
+/** Exit alternate screen buffer. */
+const ALT_EXIT = "\x1B[?1049l";
+/** Begin DEC Synchronized Update — subsequent output is buffered. */
+const BSU = "\x1B[?2026h";
+/** End DEC Synchronized Update — flush buffered output atomically. */
+const ESU = "\x1B[?2026l";
+/** Enter fullscreen mode: alt buffer only (no mouse tracking). */
+function enterFullscreen() {
+	process.stdout.write(ALT_ENTER);
+}
+/** Exit fullscreen mode: restore main buffer. */
+function exitFullscreen() {
+	process.stdout.write(ALT_EXIT);
+}
+/**
+* Wrap a synchronous callback with DEC Synchronized Update markers.
+*
+* All output written to stdout during the callback is buffered by the
+* terminal and rendered atomically, eliminating flicker during re‑renders.
+*
+* Does NOT nest — calling beginSync inside an active sync region
+* is a no‑op (tracked via module‑level flag).
+*/
+let syncActive = false;
+function beginSync() {
+	if (syncActive) return;
+	syncActive = true;
+	process.stdout.write(BSU);
+}
+function endSync() {
+	if (!syncActive) return;
+	syncActive = false;
+	process.stdout.write(ESU);
+}
+/**
+* Execute a callback within a DEC synchronized update region.
+* Exceptions propagate; sync is always ended.
+*/
+function withSync(fn) {
+	beginSync();
+	try {
+		return fn();
+	} finally {
+		endSync();
+	}
+}
+//#endregion
+//#region src/process-lifecycle.ts
+let hardExitTimer = null;
+let installed = false;
+/** Maximum time (ms) allowed for graceful shutdown before force exit. */
+const FORCE_EXIT_MS = 2e3;
+/**
+* Install process lifecycle handlers.
+*
+* Only call once. Subsequent calls are no‑ops.
+* Handles SIGINT (3‑layer abort), SIGTERM (graceful shutdown),
+* SIGHUP (graceful shutdown), and terminal loss.
+*/
+function installProcessLifecycle(config) {
+	if (installed) return;
+	installed = true;
+	const { ctx, onAbortLl, onAbortTool, incrementAbortLayer, isStreaming } = config;
+	const onSigint = () => {
+		const layer = incrementAbortLayer();
+		if (layer >= 3) {
+			exitFullscreen();
+			ctx.destroy();
+			process.exit(1);
+		}
+		if (!isStreaming()) {
+			exitFullscreen();
+			ctx.destroy();
+			process.exit(0);
+		}
+		if (layer === 1) onAbortLl();
+		else if (layer === 2) onAbortTool();
+	};
+	process.on("SIGINT", onSigint);
+	const gracefulShutdown = () => {
+		startForceExitTimer();
+		try {
+			exitFullscreen();
+		} catch {}
+		try {
+			ctx.destroy();
+		} catch {}
+		process.exit(0);
+	};
+	process.on("SIGTERM", gracefulShutdown);
+	process.on("SIGHUP", () => {
+		try {
+			const newCfg = loadConfig();
+			if (typeof newCfg.model === "string" && newCfg.model !== ctx.agentConfig.model) {
+				ctx.agentConfig.model = newCfg.model;
+				process.stderr.write(`[lynx] SIGHUP：模型已切换 → ${newCfg.model}\n`);
+			}
+			if (typeof newCfg.theme === "string") process.stderr.write(`[lynx] SIGHUP：主题已切换 → ${newCfg.theme}\n`);
+			process.stderr.write("[lynx] SIGHUP：配置已重新加载\n");
+		} catch (reloadErr) {
+			process.stderr.write(`[lynx] SIGHUP 重新加载失败：${reloadErr instanceof Error ? reloadErr.message : String(reloadErr)} — 回退到关闭流程\n`);
+			gracefulShutdown();
+		}
+	});
+	const onTerminalLost = () => {
+		startForceExitTimer();
+		try {
+			ctx.destroy();
+		} catch {}
+		process.exit(0);
+	};
+	process.stdin.on("end", onTerminalLost);
+	process.stdin.on("close", onTerminalLost);
+	process.stdout.on("close", onTerminalLost);
+	process.on("unhandledRejection", (reason) => {
+		process.stderr.write(`[lynx] 未处理的 Promise 拒绝：${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}\n`);
+		startForceExitTimer();
+		exitFullscreen();
+		ctx.destroy();
+		process.exit(1);
+	});
+	process.on("uncaughtException", (err) => {
+		process.stderr.write(`[lynx] 未捕获的异常：${err.stack ?? err.message}\n`);
+		startForceExitTimer();
+		exitFullscreen();
+		ctx.destroy();
+		process.exit(1);
+	});
+}
+/**
+* Register a cleanup handler that runs during graceful shutdown.
+* Replaces any previously registered handler.
+*/
+function onCleanup(handler) {}
+/**
+* Remove all process lifecycle handlers (for testing).
+*/
+function uninstallProcessLifecycle() {
+	installed = false;
+	process.removeAllListeners("SIGINT");
+	process.removeAllListeners("SIGTERM");
+	process.removeAllListeners("SIGHUP");
+	if (hardExitTimer) {
+		clearTimeout(hardExitTimer);
+		hardExitTimer = null;
+	}
+}
+function startForceExitTimer() {
+	if (hardExitTimer) return;
+	hardExitTimer = setTimeout(() => {
+		process.stderr.write("[lynx] 超时后强制退出\n");
+		process.exit(1);
+	}, FORCE_EXIT_MS);
+	hardExitTimer.unref();
+}
+//#endregion
+export { endSync as a, withSync as c, runPhase2WithContext as d, bootstrap as f, beginSync as i, runPhase1 as l, onCleanup as n, enterFullscreen as o, uninstallProcessLifecycle as r, exitFullscreen as s, installProcessLifecycle as t, runPhase2 as u };
+
+//# sourceMappingURL=process-lifecycle-Dg6n2QS-.mjs.map