@napuketto/loader 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 睦 <oppenheymu@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/host/self-host.cjs

@@ -0,0 +1,774 @@
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_os = require("node:os");
+//#region src/host/env.ts
+/**
+* env.ts：引导进程环境变量访问层（2026-08-07 阶段 2）。
+*
+* 根 tsconfig 开启 noPropertyAccessFromIndexSignature——process.env 是索引签名
+* 类型（Record<string, string | undefined>），点访问会报 TS4111；且 useNamingConvention
+* 不允许 typeMember 用 CONSTANT_CASE。故改为「对象字面量快照」：
+*  - 对象字面量成员允许 CONSTANT_CASE（biome 配置），键是字面量 → env.XXX 点访问合法
+*  - 快照语义：引导进程内环境变量不变（launcher spawn 前注入完毕），取一次即可
+*/
+const env = {
+	/** kernel 入口（.mjs，bootstrap 动态 import）。 */
+	NAPUTO_KERNEL_ENTRY: process.env["NAPUTO_KERNEL_ENTRY"],
+	/** QQ 版本号（appid 解析 / 协议装配用）。 */
+	NAPUTO_QQ_VERSION: process.env["NAPUTO_QQ_VERSION"],
+	/** 配置目录（数据根，日志 / 协议配置兜底）。 */
+	NAPUTO_CFG_DIR: process.env["NAPUTO_CFG_DIR"],
+	/** wrapper.node 绝对路径（dlopen 目标）。 */
+	NAPUTO_WRAPPER_PATH: process.env["NAPUTO_WRAPPER_PATH"],
+	/** adapter 包入口（协议装配用）。 */
+	NAPUTO_ADAPTER_ENTRY: process.env["NAPUTO_ADAPTER_ENTRY"],
+	/** network 包入口（协议装配用）。 */
+	NAPUTO_NETWORK_ENTRY: process.env["NAPUTO_NETWORK_ENTRY"],
+	/** 自建宿主标记（=1：标准 node + stub 引导，launcher 注入）。 */
+	NAPUTO_SELF_HOST: process.env["NAPUTO_SELF_HOST"],
+	/** stub QQNT.dll 目录（launcher 注入，self-host 诊断用）。 */
+	NAPUTO_STUB_DIR: process.env["NAPUTO_STUB_DIR"],
+	/** 强制指定快速登录账号（防风控账号挂起）。 */
+	NAPUTO_QUICK_UIN: process.env["NAPUTO_QUICK_UIN"],
+	/** 收发消息冒烟自检开关（=1 触发）。 */
+	NAPUTO_SMOKE: process.env["NAPUTO_SMOKE"],
+	/** 冒烟目标 peer（c2c:<uin> / group:<uin>，缺省发给自己）。 */
+	NAPUTO_SMOKE_PEER: process.env["NAPUTO_SMOKE_PEER"],
+	/** 运行时探测开关（=1 触发 probeRuntime）。 */
+	NAPUTO_PROBE: process.env["NAPUTO_PROBE"],
+	/** 全局 TOML 配置显式路径（优先级最高）。 */
+	NAPKETTO_CONFIG: process.env["NAPKETTO_CONFIG"],
+	/** 数据根（kernel 数据目录，cleanCache 用）。 */
+	NAPKETTO_DATA: process.env["NAPKETTO_DATA"]
+};
+//#endregion
+//#region src/host/util.ts
+/**
+* util.ts：引导公共工具（日志 + 共享状态）。
+* 2026-08-07 阶段 2：由 runtime/boot-util.js TS 化（零语义改动）。
+* 由 self-host.ts 及各拆分模块 import（CJS bundle，运行在自建宿主引导进程内）。
+*/
+/** boot 日志路径（NAPUTO_CFG_DIR 下，与 stub 验证日志同目录）。 */
+const LOG_PATH = env.NAPUTO_CFG_DIR ? (0, node_path.join)(env.NAPUTO_CFG_DIR, "napuketto-boot.log") : (0, node_path.join)((0, node_os.tmpdir)(), "napuketto-boot.log");
+/** 追加一行 boot 日志（失败静默，不阻塞引导）。 */
+function log(msg) {
+	try {
+		(0, node_fs.appendFileSync)(LOG_PATH, `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}\n`);
+	} catch {}
+}
+/** 错误信息提取（保留 JS 原语义：message 存在用 message，否则用错误对象本身）。 */
+function errMsg(e) {
+	return `${e?.message ?? e}`;
+}
+function createState() {
+	return {
+		wrapperExports: null,
+		qqSession: null,
+		qqLoginService: null,
+		bootstrapped: false
+	};
+}
+//#endregion
+//#region src/host/login.ts
+/** 打印可用快速登录账号 + 返回目标账号（启动横幅）。forcedUin（cli `-q` / NAPUTO_QUICK_UIN）优先。 */
+async function pickLoginAccount(kernel, ctx, loginResultRef, forcedUin) {
+	try {
+		const accounts = await kernel.listLoginAccounts(ctx);
+		if (accounts.length > 0) {
+			log(`可用于快速登录 of QQ（${accounts.length} 个）：`);
+			accounts.forEach((acct, idx) => {
+				const nick = acct.nickName || acct.uin;
+				const marker = acct.isQuickLogin ? "（默认）" : "";
+				log(`${idx + 1}. ${acct.uin} ${nick}${marker}`);
+			});
+			const target = forcedUin !== void 0 ? accounts.find((a) => a.uin === forcedUin) ?? void 0 : accounts.find((a) => a.isQuickLogin) ?? accounts[0];
+			if (target !== void 0) {
+				loginResultRef.targetUin = target.uin;
+				log(`正在快速登录 ${target.uin}`);
+			} else if (forcedUin !== void 0) log(`指定账号 ${forcedUin} 不在登录列表（登录流程将报错）`);
+		} else log("登录列表暂不可用（boot 阶段未 initConfig），由登录流程自动选择账号");
+	} catch (listErr) {
+		log(`bootstrap: 获取登录列表失败: ${errMsg(listErr)}`);
+	}
+}
+/**
+* 登录（快速登录 → QR 回退）。
+* @returns LoginResult | null（失败返回 null，不抛出——QR 兜底在内部）
+*/
+async function doLogin(core, opts) {
+	try {
+		return await core.login(opts);
+	} catch (loginErr) {
+		log(`bootstrap: 快速登录失败（${errMsg(loginErr)}），尝试 QR 登录`);
+		try {
+			return await core.login({
+				...opts,
+				qrFallback: true
+			});
+		} catch (qrErr) {
+			log(`bootstrap: QR 登录也失败: ${errMsg(qrErr)}`);
+			return null;
+		}
+	}
+}
+//#endregion
+//#region src/host/protocols.ts
+/**
+* protocols.ts：协议装配（登录成功后）。
+* 2026-08-07 阶段 2：由 runtime/boot-protocols.js TS 化（零语义改动）。
+* 动态 import adapter/network 入口，装配 OB11 适配器。
+* 依赖 launcher 注入的 NAPUTO_ADAPTER_ENTRY / NAPUTO_NETWORK_ENTRY。
+*/
+/**
+* 终端 ANSI 颜色（消息日志颜色分层，2026-08-07 用户定稿）：
+* `loader | 接收 <- 群聊` 灰色（背景噪音）/ `[会话]` 青色 / `[发送者]` 绿色 / 内容默认色。
+* 仅 console 版嵌入；boot 文件日志用纯文本版（log），不污染文件。
+*/
+const ANSI = {
+	gray: "\x1B[90m",
+	cyan: "\x1B[36m",
+	green: "\x1B[32m",
+	reset: "\x1B[0m"
+};
+/**
+* 登录成功后装配协议：kernel 各 Api + network 广播 + OB11 适配器。
+*/
+async function startProtocols(kernel, ctx, loginResult) {
+	const logger = kernel.createLogger?.({
+		console: true,
+		base: { name: "loader" }
+	});
+	const adapterEntry = env.NAPUTO_ADAPTER_ENTRY;
+	const networkEntry = env.NAPUTO_NETWORK_ENTRY;
+	if (!adapterEntry || !networkEntry) {
+		log("bootstrap: NAPUTO_ADAPTER_ENTRY/NETWORK_ENTRY 未设置，跳过协议装配");
+		return;
+	}
+	try {
+		const network = await import(`file://${networkEntry.replace(/\\/g, "/")}`);
+		const onebot11Entry = adapterEntry.replace(/index\.mjs$/, "onebot11/index.mjs");
+		const coreEntry = adapterEntry.replace(/index\.mjs$/, "core/index.mjs");
+		const adapter = await import(`file://${onebot11Entry.replace(/\\/g, "/")}`);
+		const adapterCore = await import(`file://${coreEntry.replace(/\\/g, "/")}`);
+		const session = ctx.session;
+		if (!session) {
+			log("bootstrap: session 为空，无法装配协议");
+			return;
+		}
+		const channel = new kernel.NTEventChannel("Msg");
+		new kernel.MsgBridge(session, channel).register();
+		channel.on("Msg/onRecvMsg", (msgs) => {
+			const list = Array.isArray(msgs) ? msgs : [msgs];
+			for (const msg of list) {
+				if (!msg || typeof msg !== "object") continue;
+				try {
+					let rendered = "";
+					for (const el of kernel.toCanonicalElements(msg)) if (el.type === "text") rendered += el.text;
+					else if (el.type === "at") {
+						const name = el.display ?? (el.target === "all" ? "全体" : el.target);
+						rendered += `@${name}`;
+					} else if (el.type === "face") rendered += "[表情]";
+					else if (el.type === "image") rendered += "[图片]";
+					else if (el.type === "voice") rendered += "[语音]";
+					else if (el.type === "video") rendered += "[视频]";
+					else if (el.type === "reply") rendered += "[回复]";
+					else if (el.type === "file") rendered += `[文件${el.name ?? ""}]`;
+					else if (el.type === "forward") rendered += "[合并转发]";
+					else if (el.type === "json") rendered += "[json]";
+					else if (el.type === "xml") rendered += "[xml]";
+					if (rendered === "") rendered = "[空消息/媒体]";
+					const isGroup = msg.chatType === kernel.ChatType.GROUP;
+					const kind = isGroup ? "群聊" : "私聊";
+					const peerUin = String(msg.peerUin ?? "");
+					const senderUin = String(msg.senderUin ?? (peerUin || "未知"));
+					const plainTags = isGroup ? `[群${peerUin}] [用户${senderUin}]` : `[用户${senderUin}]`;
+					const coloredTags = isGroup ? `${ANSI.cyan}[群${peerUin}]${ANSI.reset} ${ANSI.green}[用户${senderUin}]${ANSI.reset}` : `${ANSI.green}[用户${senderUin}]${ANSI.reset}`;
+					const content = rendered.replace(/\n/g, "\n    ");
+					const plain = `接收 <- ${kind} ${plainTags}： ${content}`;
+					const colored = `${ANSI.gray}loader | 接收 <- ${kind}${ANSI.reset} ${coloredTags}： ${content}`;
+					log(plain);
+					logger?.info(colored);
+				} catch (e) {
+					const line2 = `接收消息（解析失败: ${errMsg(e)}）`;
+					log(line2);
+					logger?.warn(line2);
+				}
+			}
+		});
+		const groupApi = new kernel.GroupApi(session);
+		const msgApi = new kernel.MsgApi(session);
+		const friendApi = new kernel.FriendApi(session, { uidToUin: (uids) => groupApi.uidToUin(uids) });
+		const groupChannel = new kernel.NTEventChannel("Group");
+		new kernel.GroupBridge(session, groupChannel).register();
+		const groupCache = new kernel.GroupCache({
+			channel: groupChannel,
+			groupApi
+		});
+		groupCache.register();
+		const groupNotifyApi = new kernel.GroupNotifyApi(session);
+		const ticketApi = new kernel.TicketApi(session);
+		const richMediaApi = new kernel.RichMediaApi(session);
+		const profileApi = new kernel.ProfileApi(session);
+		const profileLikeApi = new kernel.ProfileLikeApi(session);
+		const webApi = new kernel.WebApi({ getCookies: (domain) => ticketApi.getCookies(domain, loginResult.uin) });
+		const broadcaster = new network.EventBroadcaster();
+		let ob11Section = {};
+		const cfgFile = env.NAPKETTO_CONFIG || (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "napuketto.toml");
+		try {
+			const raw = (0, node_fs.readFileSync)(cfgFile, "utf8");
+			const parsed = kernel.parseToml(raw);
+			if (parsed && typeof parsed["onebot11"] === "object" && parsed["onebot11"] !== null) ob11Section = parsed["onebot11"];
+		} catch (e) {
+			log(`bootstrap: 全局配置读取失败（用默认 ob11 配置）: ${errMsg(e)}`);
+		}
+		const ob11Config = new adapterCore.ProtocolConfig({
+			path: cfgFile,
+			schema: adapter.ob11ConfigSchema,
+			defaults: adapter.ob11ConfigSchema.parse({}),
+			seed: adapter.ob11ConfigSchema.parse(ob11Section)
+		});
+		await new adapter.NapukettoOneBot11Adapter({
+			config: ob11Config,
+			broadcaster,
+			msgChannel: channel,
+			msgApi,
+			groupApi,
+			groupNotifyApi,
+			friendApi,
+			ticketApi,
+			richMediaApi,
+			profileApi,
+			profileLikeApi,
+			webApi,
+			self: {
+				uin: loginResult.uin,
+				nickname: loginResult.nick
+			},
+			system: {
+				appVersion: env.NAPUTO_QQ_VERSION || "unknown",
+				cleanCache: async () => {
+					new kernel.PathWrapper({
+						dataRoot: env.NAPKETTO_DATA,
+						account: loginResult.uin
+					}).clearCache();
+				},
+				cacheDir: (0, node_path.join)(env.NAPUTO_CFG_DIR || ".", "cache"),
+				exit: async () => {
+					log("bootstrap: bot_exit 触发，退出 QQ 主进程");
+					process.exit(0);
+				},
+				restart: async () => {
+					log("bootstrap: set_restart 触发，退出 QQ 主进程（由 launcher 重启）");
+					process.exit(0);
+				}
+			},
+			groupCache
+		}).start();
+		log("bootstrap: onebot11 adapter started");
+	} catch (e) {
+		log(`bootstrap: 协议装配失败: ${errMsg(e)}`);
+	}
+}
+//#endregion
+//#region src/host/session.ts
+/** 对象有效性判断：getMsgService() 调用不抛断言（cpp_impl 已激活）。
+* 与 isSessionUsable 的区别：这里允许返回 null（未 init 但对象有效）。 */
+function isSessionObjectValid(s) {
+	if (!s) return false;
+	try {
+		s.getMsgService();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** session 可用性判断：getMsgService() 可调且非 null（核心 service 已挂载）。 */
+function isSessionUsable(s) {
+	if (!s) return false;
+	try {
+		const svc = s.getMsgService();
+		return svc !== null && svc !== void 0;
+	} catch {
+		return false;
+	}
+}
+/** session 就绪探测（5s 间隔，60s 上限）——观察 qqSession / get() 状态。 */
+function startSessionProbe(state, _ctx, durationMs = 6e4) {
+	const sessionProbe = setInterval(() => {
+		try {
+			const S2 = state.wrapperExports?.["NodeIQQNTWrapperSession"];
+			const out = [];
+			const describe = (s) => {
+				if (!s) return "null";
+				try {
+					const sess = s;
+					const id = typeof sess.getSessionId === "function" ? String(sess.getSessionId()) : "?";
+					const svc = typeof sess.getMsgService === "function" ? sess.getMsgService() : null;
+					return `id=${id} msgSvc=${svc !== null && svc !== void 0 ? "READY" : "null"}`;
+				} catch (e) {
+					return `id=? msgSvc=断言(${errMsg(e).slice(0, 60)})`;
+				}
+			};
+			if (state.qqSession && typeof state.qqSession.getMsgService === "function") out.push(`qqSession[${describe(state.qqSession)}]`);
+			if (S2 && typeof S2.get === "function") {
+				const got = S2.get();
+				out.push(`get()[${describe(got)}]`);
+			}
+			if (S2 && typeof S2.getNTWrapperSession === "function") {
+				const gotNT = S2.getNTWrapperSession("Session");
+				if (gotNT) out.push(`getNT("Session")[${describe(gotNT)}]`);
+			}
+			log(`BOOT: session 探测: ${out.join(" | ")}`);
+		} catch (e) {
+			log(`BOOT: session 探测失败: ${errMsg(e)}`);
+		}
+	}, 5e3);
+	setTimeout(() => clearInterval(sessionProbe), durationMs);
+	return sessionProbe;
+}
+/** 探测 session 方法面（NAPI 反射，验证 startNT/init 等关键方法）。 */
+function probeSessionMethods(ctx) {
+	try {
+		const s = ctx.session;
+		if (s) {
+			const names = [...Object.getOwnPropertyNames(Object.getPrototypeOf(s) ?? {}), ...Object.keys(s)];
+			log(`bootstrap: session methods(${names.length}): ${[...new Set(names)].join(", ")}`);
+			log(`bootstrap: session.init=${typeof s["init"]} startNT=${typeof s["startNT"]} getMsgService=${typeof s["getMsgService"]}`);
+		}
+	} catch (e) {
+		log(`bootstrap: session 探测失败: ${errMsg(e)}`);
+	}
+}
+/** 收集候选 session（按优先级：QQ 主 session → vehicle 激活 session → get() → qqSession）。 */
+function collectCandidateSessions(state, kernel, ctx) {
+	const candidates = [];
+	const S2 = state.wrapperExports?.["NodeIQQNTWrapperSession"];
+	try {
+		if (typeof kernel.getMainSession === "function") {
+			const ms = kernel.getMainSession(ctx);
+			if (ms) candidates.push({
+				s: ms,
+				tag: "getMainSession(nt_x)"
+			});
+		}
+	} catch (e) {
+		log(`bootstrap: getMainSession 失败: ${errMsg(e)}`);
+	}
+	try {
+		if (S2 && typeof S2.getNTWrapperSession === "function") {
+			const got = S2.getNTWrapperSession("Session");
+			if (got) candidates.push({
+				s: got,
+				tag: "getNT(Session)"
+			});
+		}
+	} catch (e) {
+		log(`bootstrap: getNTWrapperSession 失败: ${errMsg(e)}`);
+	}
+	try {
+		if (S2 && typeof S2.get === "function") {
+			const got = S2.get();
+			if (got) candidates.push({
+				s: got,
+				tag: "get()"
+			});
+		}
+	} catch (e) {
+		log(`bootstrap: get() 失败: ${errMsg(e)}`);
+	}
+	if (state.qqSession) candidates.push({
+		s: state.qqSession,
+		tag: "qqSession"
+	});
+	return candidates;
+}
+/** 从候选里选最佳 session：优先有效对象，且 READY（msgSvc 非 null）优先。 */
+function pickBestSession(candidates) {
+	let bestValid = null;
+	for (const c of candidates) {
+		const ready = isSessionUsable(c.s);
+		const valid = isSessionObjectValid(c.s);
+		log(`bootstrap: 候选 ${c.tag}: valid=${valid} msgSvc=${ready ? "READY" : "null/断言"}`);
+		if (valid && bestValid === null) bestValid = c;
+		if (ready) return c;
+	}
+	return bestValid;
+}
+//#endregion
+//#region src/host/smoke.ts
+/**
+* smoke.ts：P2-1 收发消息冒烟自检（NAPUTO_SMOKE=1 触发，2026-08-06）。
+* 2026-08-07 阶段 2：由 runtime/boot-smoke.js TS 化（零语义改动）。
+*
+* 目的：业务层最后试金石——登录 + session 就绪后，真正用 kernel MsgBridge
+* （addKernelMsgListener）+ MsgApi（sendMsg）发/收一条消息，验证：
+*  ① 发送方向：MsgApi.sendMessage 成功返回 msgId（NT 雪花 ID）
+*  ② 接收方向：MsgBridge 订阅 onRecvMsg 收到消息事件
+*  ③ 落库验证：fetchMessages 拉取最近消息，确认刚发的消息在列表里
+*
+* 目标 peer 由环境变量 NAPUTO_SMOKE_PEER 指定（格式：c2c:<uin> 或 group:<uin>），
+* 缺省发给自己的 uin（C2C 我的设备）。发送内容固定带时间戳，便于日志核对。
+*
+* 由 bootstrap.ts 在登录成功、session 就绪后调用（协议装配前——不依赖
+* adapter/network，单独验证 kernel 业务链路）。
+*/
+/** 冒烟测试默认等待（毫秒）。 */
+const SMOKE_SETTLE_MS = 5e3;
+/** 解析冒烟目标：NAPUTO_SMOKE_PEER（c2c:<uin> / group:<uin>），缺省发给自己。 */
+function parseSmokeTarget(envPeer, selfUin) {
+	if (!envPeer) return {
+		kind: "c2c",
+		uin: selfUin
+	};
+	const [kind, uin = ""] = envPeer.split(":");
+	if (kind === "group" && uin !== "") return {
+		kind: "group",
+		uin
+	};
+	if (kind === "c2c" && uin !== "") return {
+		kind: "c2c",
+		uin
+	};
+	return {
+		kind: "c2c",
+		uin: selfUin
+	};
+}
+/** uin → uid（c2c 目标用；group 直接拿群号作 peerUid）。 */
+async function resolvePeerUid(kernel, ctx, target, selfUid) {
+	const groupApi = new kernel.GroupApi(ctx.session);
+	if (target.kind === "group") return {
+		chatType: kernel.ChatType.GROUP,
+		peerUid: target.uin
+	};
+	if (target.uin === String(ctx.login?.uin ?? "")) return {
+		chatType: kernel.ChatType.C2C,
+		peerUid: selfUid
+	};
+	const uid = (await groupApi.uinToUid([target.uin])).get(target.uin);
+	if (!uid) throw new Error(`uinToUid 解析失败: ${target.uin}`);
+	return {
+		chatType: kernel.ChatType.C2C,
+		peerUid: uid
+	};
+}
+/**
+* 执行冒烟自检：注册 MsgBridge → 订阅 onRecvMsg → 发一条消息 → 拉历史核对。
+* @returns 是否全部通过（发送成功 + 收到事件 + 落库验证）
+*/
+async function runSmokeTest(kernel, ctx, loginResult) {
+	const session = ctx.session;
+	if (!session) {
+		log("smoke: ❌ session 为空，跳过");
+		return false;
+	}
+	const target = parseSmokeTarget(env.NAPUTO_SMOKE_PEER, loginResult.uin);
+	log(`smoke: 目标=${target.kind}:${target.uin}（peer env=${env.NAPUTO_SMOKE_PEER ?? "(缺省=自己)"}）`);
+	const channel = new kernel.NTEventChannel("Msg");
+	const bridge = new kernel.MsgBridge(session, channel);
+	bridge.register();
+	log("smoke: ✅ MsgBridge 注册完成（addKernelMsgListener）");
+	let received = 0;
+	let receivedText = "";
+	channel.on("Msg/onRecvMsg", (msgs) => {
+		const list = Array.isArray(msgs) ? msgs : [msgs];
+		for (const msg of list) {
+			if (!msg || typeof msg !== "object") continue;
+			received += 1;
+			try {
+				const texts = kernel.toCanonicalElements(msg).filter((el) => el.type === "text").map((el) => el.text).join("");
+				if (texts) receivedText = texts;
+			} catch (e) {
+				log(`smoke: onRecvMsg 解析失败: ${errMsg(e)}`);
+			}
+			log(`smoke: 📥 onRecvMsg 收到 #${received}（msgId=${msg.msgId ?? "?"} seq=${msg.msgSeq ?? "?"} text="${receivedText}"）`);
+		}
+	});
+	const msgApi = new kernel.MsgApi(session);
+	const peer = await resolvePeerUid(kernel, ctx, target, loginResult.uid);
+	const content = `NapukettoQQ smoke test ${Date.now()}`;
+	let sentMsgId = "";
+	try {
+		const { msgId } = await msgApi.sendMessage(peer, [{
+			type: "text",
+			text: content
+		}]);
+		sentMsgId = msgId;
+		log(`smoke: ✅ 发送成功 msgId=${msgId}（content="${content}"）`);
+	} catch (e) {
+		log(`smoke: ❌ 发送失败: ${errMsg(e)}`);
+	}
+	await new Promise((r) => setTimeout(r, SMOKE_SETTLE_MS));
+	let landed = false;
+	try {
+		const recent = await msgApi.fetchMessages(peer, { count: 10 });
+		landed = recent.some((m) => m.msgId === sentMsgId || m.msgSeq === sentMsgId);
+		log(`smoke: 落库验证: 最近 ${recent.length} 条${landed ? " ✅ 含刚发消息" : " ❌ 未找到（可能同步延迟）"}`);
+		if (!landed) for (const m of recent.slice(0, 3)) {
+			const texts = kernel.toCanonicalElements(m).filter((el) => el.type === "text").map((el) => el.text).join("");
+			log(`smoke:   最近消息 msgId=${m.msgId} seq=${m.msgSeq} text="${texts}"`);
+		}
+	} catch (e) {
+		log(`smoke: 落库验证失败: ${errMsg(e)}`);
+	}
+	try {
+		bridge.unregister();
+		log("smoke: ✅ MsgBridge 已注销");
+	} catch (e) {
+		log(`smoke: 注销失败（忽略）: ${errMsg(e)}`);
+	}
+	const ok = sentMsgId !== "" && (received > 0 || landed);
+	log(`smoke: ===== 冒烟${ok ? "✅ 通过" : "❌ 未完全通过"}（发送=${sentMsgId !== "" ? "OK" : "FAIL"}，收到事件=${received}，落库=${landed}）=====`);
+	return ok;
+}
+//#endregion
+//#region src/host/bootstrap.ts
+/**
+* bootstrap.ts：kernel 引导核心（import kernel → 装配 → 登录 → session 替换 → 协议装配）。
+* 2026-08-07 阶段 2：由 runtime/boot-bootstrap.js TS 化（零语义改动）。
+* 由 self-host.ts（自建宿主，2026-08-07 唯一路线）在 dlopen wrapper.node 后调用。
+*
+* 2026-08-07 阶段 1 拆分（零语义改动）：
+*  - 登录流程（选账号 / 快速登录 / QR 回退）→ login.ts
+*  - session 选择 / 探测 / 就绪 → session.ts
+*  - 协议装配 → protocols.ts；冒烟自检 → smoke.ts
+*
+* session 来源（2026-08-07 实测结论；V1 Proxy 捕获与 vehicle 载具已归档 archive/）：
+*  登录成功后按优先级取 session：
+*    ① kernel.getMainSession(ctx)（startup 链路 getNTWrapperSession(nt_x)——QQ 主 session，
+*      渲染进程已完成 init → getMsgService READY）
+*    ② get() / qqSession（V1 兼容）
+*  取到后 core.setSession 替换 → waitSessionReady 确认 getMsgService READY。
+*/
+/** 核心引导：import kernel → 装配 → 登录 → 替换 session → 等待就绪 → 协议装配。 */
+async function bootstrap(state) {
+	const kernelEntry = env.NAPUTO_KERNEL_ENTRY;
+	if (!kernelEntry) {
+		log("bootstrap: NAPUTO_KERNEL_ENTRY not set");
+		return;
+	}
+	try {
+		const kernel = await import(`file://${kernelEntry.replace(/\\/g, "/")}`);
+		log(`bootstrap: kernel imported, keys: ${Object.keys(kernel).join(", ")}`);
+		if (typeof kernel.startNapuketto !== "function" && typeof kernel.NapukettoCore !== "function") {
+			log("bootstrap: kernel 无 startNapuketto/NapukettoCore 导出");
+			return;
+		}
+		const bootEnv = {
+			qqVersion: env.NAPUTO_QQ_VERSION,
+			dataDir: env.NAPUTO_CFG_DIR,
+			wrapperPath: env.NAPUTO_WRAPPER_PATH
+		};
+		const Appid = typeof kernel.parseAppidFromMajor === "function" && bootEnv.wrapperPath && kernel.parseAppidFromMajor((0, node_path.join)((0, node_path.dirname)(bootEnv.wrapperPath), "major.node")) || typeof kernel.resolveAppidQua === "function" && kernel.resolveAppidQua(bootEnv.qqVersion || "").appid || "537237765";
+		log(`bootstrap: appid=${Appid}（wrapper=${bootEnv.wrapperPath}）`);
+		try {
+			if (kernel.NapukettoCore !== void 0) {
+				const core = kernel.NapukettoCore.create({
+					paths: { dataRoot: bootEnv.dataDir },
+					logLevel: "info"
+				});
+				const ctx = core.attachWrapper(state.wrapperExports, bootEnv);
+				log(`bootstrap: attachWrapper OK, engine=${typeof ctx.engine}, session=${ctx.session !== null}`);
+				try {
+					const S2 = state.wrapperExports?.["NodeIQQNTWrapperSession"];
+					const created = S2 && typeof S2.create === "function" ? S2.create() : null;
+					log(`BOOT: create()===qqSession? ${created === state.qqSession} | create()===ctx.session? ${created === ctx.session} | qqSession===ctx.session? ${state.qqSession === ctx.session}`);
+					const sess = created;
+					const svc = sess && typeof sess.getMsgService === "function" ? sess.getMsgService() : null;
+					const qs = state.qqSession;
+					log(`BOOT: create().getMsgService=${svc !== null && svc !== void 0 ? "ready" : "null"} qqSession.getMsgService=${qs && typeof qs.getMsgService === "function" && qs.getMsgService() !== null && qs.getMsgService() !== void 0 ? "ready" : "null"}`);
+				} catch (e) {
+					log(`BOOT: create() 探测失败: ${errMsg(e)}`);
+				}
+				startSessionProbe(state, ctx);
+				probeSessionMethods(ctx);
+				let loginResult = null;
+				if (typeof core.login === "function") {
+					const forcedUin = env.NAPUTO_QUICK_UIN;
+					const ref = { targetUin: void 0 };
+					await pickLoginAccount(kernel, ctx, ref, forcedUin);
+					loginResult = await doLogin(core, {
+						appid: Appid,
+						initTimeoutMs: 2e4,
+						...forcedUin ? { quickUin: forcedUin } : ref.targetUin !== void 0 ? { quickUin: ref.targetUin } : {}
+					});
+					if (loginResult === null) {
+						log("bootstrap: 登录失败，引导中止");
+						return;
+					}
+					log(`bootstrap: 登录成功 uin=${loginResult.uin} uid=${loginResult.uid} nick=${loginResult.nick}`);
+					const isSelfHost = env.NAPUTO_SELF_HOST === "1";
+					let chosen = null;
+					if (!isSelfHost) chosen = pickBestSession(collectCandidateSessions(state, kernel, ctx));
+					if (chosen && chosen.s !== ctx.session) {
+						core.setSession(chosen.s);
+						log(`bootstrap: 已替换 session（来源=${chosen.tag}，msgSvc=${isSessionUsable(chosen.s) ? "READY" : "null"}）`);
+					} else if (chosen) log(`bootstrap: 候选 session 与 ctx.session 相同（${chosen.tag}）`);
+					else log("bootstrap: 无有效候选 session（保留 kernel 自建 session）");
+					const activateTarget = chosen ?? {
+						s: ctx.session,
+						tag: "kernel 自建 session"
+					};
+					if (activateTarget.s && !isSessionUsable(activateTarget.s)) {
+						log(`bootstrap: 激活 session（${activateTarget.tag}，先 init 后 startupSession.start）...`);
+						try {
+							const qqDataRoot = typeof kernel.resolveQqUserDataRoot === "function" ? kernel.resolveQqUserDataRoot(state.wrapperExports) : null;
+							const accountPath = qqDataRoot && typeof kernel.resolveQqGlobalPath === "function" ? kernel.resolveQqGlobalPath(qqDataRoot) : bootEnv.dataDir || ".";
+							const sessionConfig = kernel.buildSessionConfig({
+								appid: Appid,
+								fullVersion: bootEnv.qqVersion || "",
+								selfUin: loginResult.uin,
+								selfUid: loginResult.uid,
+								accountPath,
+								downloadPath: (0, node_path.join)(accountPath, "NapCat", "temp")
+							});
+							const listener = kernel.createLifecycleSessionListener();
+							await kernel.initAndStartSession(ctx, sessionConfig, listener, { timeoutMs: 2e4 });
+							log("bootstrap: 激活 session init + start 完成");
+						} catch (initErr) {
+							log(`bootstrap: 激活 session init 失败: ${errMsg(initErr)}`);
+						}
+					}
+					try {
+						await kernel.waitSessionReady(ctx, { timeoutMs: 3e4 });
+						log("bootstrap: QQ session 就绪（getMsgService 可用）");
+					} catch (readyErr) {
+						log(`bootstrap: 等待 session 就绪失败: ${errMsg(readyErr)}`);
+					}
+					if (env.NAPUTO_SMOKE === "1" && loginResult !== null) try {
+						log(`bootstrap: 冒烟自检${await runSmokeTest(kernel, ctx, loginResult) ? "通过" : "未完全通过"}（见上文 smoke 日志）`);
+					} catch (smokeErr) {
+						log(`bootstrap: 冒烟自检异常: ${errMsg(smokeErr)}`);
+					}
+				} else log("bootstrap: kernel core missing login fn");
+				if (loginResult !== null) await startProtocols(kernel, ctx, loginResult);
+				if (env.NAPUTO_PROBE === "1" && typeof kernel.probeRuntime === "function") try {
+					const probe = kernel.probeRuntime(ctx);
+					log(`bootstrap: probe done, session=${probe.session ? "ok" : "null"}, services=${Object.keys(probe.services ?? {}).length}`);
+					setTimeout(() => {
+						try {
+							if (typeof kernel.probeRuntime !== "function") return;
+							const late = kernel.probeRuntime(ctx, "napuketto-probe-late.json");
+							log(`bootstrap: probe-late done, session=${late.session ? "ok" : "null"}, services=${Object.keys(late.services ?? {}).length}`);
+						} catch (e2) {
+							log(`bootstrap: probe-late error: ${errMsg(e2)}`);
+						}
+					}, 35e3);
+				} catch (e) {
+					log(`bootstrap: probe error: ${errMsg(e)}`);
+				}
+			} else {
+				log("bootstrap: kernel has no NapukettoCore, falling back");
+				const ctx = kernel.startNapuketto?.({
+					wrapperExports: state.wrapperExports,
+					env: bootEnv
+				});
+				if (ctx === void 0) {
+					log("bootstrap: startNapuketto 不可用");
+					return;
+				}
+				log(`bootstrap: startNapuketto OK, engine=${typeof ctx.engine}, session=${ctx.session !== null}`);
+				if (typeof kernel.quickLogin === "function" && typeof kernel.initAndStartSession === "function") {
+					if (typeof kernel.buildLoginConfig === "function" && ctx.loginService) {
+						const loginCfg = kernel.buildLoginConfig(Appid, bootEnv.qqVersion || "", bootEnv.dataDir || ".");
+						if (typeof ctx.loginService.initConfig === "function") {
+							ctx.loginService.initConfig(loginCfg);
+							log("bootstrap: loginService.initConfig OK");
+						}
+					}
+					const loginResult = await kernel.quickLogin(ctx, {});
+					log(`bootstrap: quickLogin OK, uin=${loginResult.uin}, uid=${loginResult.uid}`);
+					const sessionConfig = kernel.buildSessionConfig({
+						appid: Appid,
+						fullVersion: bootEnv.qqVersion || "",
+						selfUin: loginResult.uin,
+						selfUid: loginResult.uid,
+						accountPath: bootEnv.dataDir || ".",
+						downloadPath: (0, node_path.join)(bootEnv.dataDir || ".", "temp")
+					});
+					const listener = kernel.createLifecycleSessionListener();
+					await kernel.initAndStartSession(ctx, sessionConfig, listener, { timeoutMs: 2e4 });
+					log("bootstrap: session init + startNT OK!");
+				} else log("bootstrap: kernel missing lifecycle fns (quickLogin/initAndStartSession)");
+				if (env.NAPUTO_PROBE === "1" && typeof kernel.probeRuntime === "function") try {
+					const probe = kernel.probeRuntime(ctx);
+					log(`bootstrap: probe done, session=${probe.session ? "ok" : "null"}, services=${Object.keys(probe.services ?? {}).length}`);
+				} catch (e) {
+					log(`bootstrap: probe error: ${errMsg(e)}`);
+				}
+			}
+		} catch (e) {
+			log(`bootstrap: lifecycle error: ${errMsg(e)}`);
+		}
+	} catch (e) {
+		log(`bootstrap: import kernel failed: ${errMsg(e)}`);
+	}
+}
+//#endregion
+//#region src/host/self-host.ts
+/**
+* self-host.ts：自建宿主（路线 A，NAPUTO_SELF_HOST）入口——标准 Node 进程直接运行。
+* 2026-08-07 阶段 2：由 runtime/self-host.cjs TS 化（零语义改动）。
+* 由 loader launcher.launchSelfHost() spawn 标准 node 启动；环境变量继承。
+*
+* 背景（2026-08-07 HANDOVER-V6/V9 实测，勿重复探索）：
+*  - 纯 Node（系统 node）+ stub QQNT.dll 转发 + 9.9.33 官方 wrapper.node 可完整登录，
+*    且 session 业务 service 全部 READY（getMsgService 298 方法）。
+*  - 与路线 B（注入 QQ worker，继承 QQ env）不同：标准 node 没有 QQ 的环境与事件分发
+*    对象，必须手动完成三要素：
+*      ① 加载 = stub QQNT.dll 转发（napi_* → node.exe，PATH 前置 stub 目录，
+*         launcher.launchSelfHost 负责装配 PATH）
+*      ② `NodeIO3MiscService.get()` + `addO3MiscListener` 激活事件分发
+*         （否则 getLoginList 永不 resolve——挂起，V6 实测）
+*      ③ commonPath/desktopGlobalPath = 数据根/nt_qq/global（kernel 已按
+*         electronProcessType() !== "browser" 自动解析，见 wrapper-loader.ts）
+*
+* 职责（本文件只做自建宿主特有的引导前置，业务链路完全复用）：
+*  1. process.dlopen(wrapper.node) → exports（98 个，stub 提供宿主符号）
+*  2. O3MiscService 激活事件分发
+*  3. 构造 state（wrapperExports）→ 调 bootstrap(state)
+*     → kernel 装配 → 登录（快速/QR）→ session（先 init 后 start）→ 冒烟 → 协议装配
+*/
+const state = createState();
+log(`[self-host] 启动 @ ${(/* @__PURE__ */ new Date()).toISOString()} pid=${process.pid} node=${process.version} type=${process.type ?? "(标准 node)"}`);
+log(`[self-host] stub 目录: ${env.NAPUTO_STUB_DIR ?? "(PATH 前置，未记录)"}`);
+const wrapperPath = env.NAPUTO_WRAPPER_PATH;
+if (!wrapperPath) {
+	log("[self-host] NAPUTO_WRAPPER_PATH 未设置，退出");
+	process.exit(1);
+}
+log(`[self-host] dlopen wrapper.node: ${wrapperPath}`);
+try {
+	const m = { exports: {} };
+	process.dlopen(m, wrapperPath);
+	const keys = Object.keys(m.exports ?? {});
+	log(`[self-host] ✅ dlopen 成功，exports ${keys.length} 个`);
+	if (!keys.includes("NodeIKernelLoginService")) {
+		log("[self-host] ❌ exports 无 NodeIKernelLoginService（stub 环境异常？）");
+		process.exit(1);
+	}
+	state.wrapperExports = m.exports;
+} catch (e) {
+	log(`[self-host] ❌ dlopen 失败: ${errMsg(e)}`);
+	process.exit(1);
+}
+try {
+	const O3 = state.wrapperExports?.["NodeIO3MiscService"];
+	if (O3 && typeof O3.get === "function") {
+		O3.get().addO3MiscListener({ getOnAmgomDataPiece() {} });
+		log("[self-host] ✅ O3MiscService 激活事件分发");
+	} else log("[self-host] ⚠️ NodeIO3MiscService 缺失（版本变化？继续尝试）");
+} catch (e) {
+	log(`[self-host] ⚠️ O3MiscService 激活失败: ${errMsg(e)}`);
+}
+log("[self-host] 调 bootstrap(state) ...");
+(async () => {
+	try {
+		await bootstrap(state);
+		log("[self-host] bootstrap 完成");
+	} catch (e) {
+		log(`[self-host] bootstrap 失败: ${errMsg(e)}`);
+		process.exit(1);
+	}
+})();
+//#endregion

package/dist/index.d.mts

@@ -0,0 +1,99 @@
+import { StdioOptions, spawn } from "node:child_process";
+//#region src/locate-qq.d.ts
+/** QQ 安装目录探测结果。 */
+interface QqInstallInfo {
+  /** QQ.exe 绝对路径。 */
+  qqPath: string;
+  /** 安装根目录。 */
+  installDir: string;
+  /** 当前版本目录名（如 9.9.31-49919）。 */
+  version: string;
+  /** wrapper.node 绝对路径。 */
+  wrapperPath: string;
+}
+/** 找 QQ.exe 路径。 */
+declare function locateQqPath(): string;
+/** 从 QQ.exe 路径推导安装目录，并探测当前版本。 */
+declare function resolveQqInstall(qqPath?: string): QqInstallInfo;
+//#endregion
+//#region src/launcher.d.ts
+interface LaunchOptions {
+  /** QQ 安装信息（qqPath/version/wrapperPath）。 */
+  qq: QqInstallInfo;
+  /** kernel 入口（.mjs，self-host.cjs 里 import）。 */
+  kernelEntry: string;
+  /** 配置目录（账号数据目录，NAPUTO_CFG_DIR）。 */
+  cfgDir: string;
+  /** 全局配置文件路径（项目根 napuketto.toml，注入 NAPKETTO_CONFIG 供装配链读取）。 */
+  configPath?: string;
+  /** adapter 入口（.mjs，协议装配用）。 */
+  adapterEntry?: string;
+  /** network 入口（.mjs，协议装配用）。 */
+  networkEntry?: string;
+  /** 自建宿主：标准 node + stub QQNT.dll 直接引导，不拉起 QQ（2026-08-07 唯一路线）。 */
+  selfHost?: boolean;
+  /** stub QQNT.dll 目录（PATH 前置，转发 napi_*、uv_* 符号到 node.exe）。 */
+  stubDir?: string;
+  /** 强制指定快速登录账号（注入 NAPUTO_QUICK_UIN；cli `-q <uin>` 透传，2026-08-07）。 */
+  quickUin?: string;
+  /** 自建宿主入口（默认 dist/host/self-host.cjs）。 */
+  selfHostEntry?: string;
+  /**
+   * 子进程工作目录（缺省继承父进程 cwd）。
+   *
+   * ⚠️ 必须指向数据根（~/.napuketto）：QQ 原生层在账号上下文就绪前会
+   * fallback 到进程 cwd 落盘（如频道库 guild1.db），不指定则污染调用方
+   * 目录（实测写入项目根，guild1.db 08-07）。cli 传 dataRoot 根治。
+   */
+  cwd?: string;
+  /**
+   * 子进程 stdio（默认 "inherit"）。cli 传 ["inherit","pipe","pipe"] 并接管
+   * 子进程 stdout/stderr：逐行过滤 wrapper 原生噪音（MMKV 刷屏、Node 符号
+   * 查找失败警告），其余转发——原生 printf 直写 fd 的字节无法从 JS 层拦截。
+   */
+  stdio?: StdioOptions;
+}
+interface LaunchResult {
+  /** 子进程句柄（自建宿主 node 进程）。 */
+  child: ReturnType<typeof spawn>;
+  /** 自建宿主入口路径（self-host.cjs）。 */
+  bootJsPath: string;
+}
+/**
+ * 启动自建宿主（路线 A，2026-08-07 产品化）：spawn 标准 node 直接跑 self-host.cjs，
+ * 不拉起 QQ / 不注入。
+ *
+ * 关键（HANDOVER-V7 技术数据）：wrapper.node 从 QQNT.dll 导入 99 符号
+ * （napi_*×40 + uv_*×56 + qq_magic×1 + v8/node mangled×2）——标准 node 无这些宿主
+ * 符号，必须 PATH 前置 stub QQNT.dll 目录（转发到 node.exe）+ QQ resources\app
+ * （wrapper.node 同目录依赖 DLL）才能 dlopen 成功。
+ */
+declare function launchSelfHost(options: LaunchOptions): LaunchResult;
+/**
+ * 默认 stub QQNT.dll 目录（loader 包内闭源 native/build/stub-test-env，开发机默认）。
+ * src 与 native 同层，构建后 dist 与 native 同层——`../native` 恒正确。
+ */
+declare function defaultStubDir(): string;
+/** 环境变量名（self-host.cjs 与 kernel 引导读取）。 */
+declare const ENV: {
+  readonly QQ_PATH: "NAPUTO_QQ_PATH";
+  readonly KERNEL_ENTRY: "NAPUTO_KERNEL_ENTRY";
+  readonly CFG_DIR: "NAPUTO_CFG_DIR";
+  readonly QQ_VERSION: "NAPUTO_QQ_VERSION";
+  readonly WRAPPER_PATH: "NAPUTO_WRAPPER_PATH";
+  /** 自建宿主：标准 node + stub QQNT.dll 引导（self-host.cjs 分支）。 */
+  readonly SELF_HOST: "NAPUTO_SELF_HOST";
+  /** stub QQNT.dll 目录（launchSelfHost 注入，self-host.cjs 诊断用）。 */
+  readonly STUB_DIR: "NAPUTO_STUB_DIR";
+  /** adapter 包入口（协议装配用）。 */
+  readonly ADAPTER_ENTRY: "NAPUTO_ADAPTER_ENTRY";
+  /** network 包入口（协议装配用）。 */
+  readonly NETWORK_ENTRY: "NAPUTO_NETWORK_ENTRY";
+  /** 全局配置文件路径（项目根 napuketto.toml，boot-protocols 读取）。 */
+  readonly CONFIG_PATH: "NAPKETTO_CONFIG";
+  /** 强制指定快速登录账号（cli `-q <uin>` 透传，bootstrap 登录用）。 */
+  readonly QUICK_UIN: "NAPUTO_QUICK_UIN";
+};
+//#endregion
+export { ENV, type LaunchOptions, type LaunchResult, type QqInstallInfo, defaultStubDir, launchSelfHost, locateQqPath, resolveQqInstall };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/locate-qq.ts","../src/launcher.ts"],"mappings":";;;UAuDiB;;EAEb;;EAEA;;EAEA;;EAEA;;;iBAIY;;iBAaA,iBAAiB,kBAAkB;;;UC9DlC;;EAEb,IAAI;;EAEJ;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;EAQA;;;;;;EAMA,QAAQ;;UAGK;;EAEb,OAAO,kBAAkB;;EAEzB;;;;;;;;;;;iBAYY,eAAe,SAAS,gBAAgB;;;;;iBAiDxC;;cAqCH;WACT;WACA;WACA;WACA;WACA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA"}

package/dist/index.mjs

@@ -0,0 +1,159 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+//#region src/launcher.ts
+/**
+* launcher：自建宿主引导（2026-08-07 唯一路线）——spawn 标准 node 跑 self-host.cjs。
+*
+* 历史（V1/路线 B 事实链，已归档 archive/）：
+*  1. wrapper.node 只能在 QQ 定制版 Electron 里注册（实测纯 Node/普通 Electron 均 self-register 失败）
+*  2. QQ 是打包应用，禁 NODE_OPTIONS（实测 stderr）
+*  → 旧方案：NapukettoBootMain.exe 启动 QQ + 注入 NapukettoWinBootHook.dll（已废弃）
+*  → 现方案：stub QQNT.dll 转发宿主符号 → 标准 node 直接 dlopen wrapper.node（自建宿主）
+*/
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+* 启动自建宿主（路线 A，2026-08-07 产品化）：spawn 标准 node 直接跑 self-host.cjs，
+* 不拉起 QQ / 不注入。
+*
+* 关键（HANDOVER-V7 技术数据）：wrapper.node 从 QQNT.dll 导入 99 符号
+* （napi_*×40 + uv_*×56 + qq_magic×1 + v8/node mangled×2）——标准 node 无这些宿主
+* 符号，必须 PATH 前置 stub QQNT.dll 目录（转发到 node.exe）+ QQ resources\app
+* （wrapper.node 同目录依赖 DLL）才能 dlopen 成功。
+*/
+function launchSelfHost(options) {
+	const selfHostPath = options.selfHostEntry ?? join(__dirname, "..", "dist", "host", "self-host.cjs");
+	if (!existsSync(selfHostPath)) throw new Error(`self-host.cjs 缺失: ${selfHostPath}（先运行 pnpm --filter @napuketto/loader build）`);
+	const stub = options.stubDir ?? defaultStubDir();
+	if (!existsSync(join(stub, "QQNT.dll"))) throw new Error(`stub QQNT.dll 未找到: ${stub}（自建宿主必需：stub 转发 QQNT.dll 符号到 node.exe；请用 --stub-dir 或环境变量 NAPUTO_STUB_DIR 指定 stub 目录）`);
+	const env = buildLaunchEnv(options);
+	env["PATH"] = [
+		stub,
+		dirname(options.qq.wrapperPath),
+		process.env["PATH"] ?? ""
+	].filter((p) => p !== void 0 && p !== "").join(";");
+	env[ENV.STUB_DIR] = stub;
+	if (options.cwd !== void 0) mkdirSync(options.cwd, { recursive: true });
+	return {
+		child: spawn(process.execPath, [selfHostPath], {
+			...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+			env,
+			stdio: options.stdio ?? "inherit",
+			windowsHide: false
+		}),
+		bootJsPath: selfHostPath
+	};
+}
+/**
+* 默认 stub QQNT.dll 目录（loader 包内闭源 native/build/stub-test-env，开发机默认）。
+* src 与 native 同层，构建后 dist 与 native 同层——`../native` 恒正确。
+*/
+function defaultStubDir() {
+	return join(__dirname, "..", "native", "build", "stub-test-env");
+}
+/** 装配自建宿主环境变量。 */
+function buildLaunchEnv(options) {
+	const cfg = resolve(options.cfgDir);
+	mkdirSync(cfg, { recursive: true });
+	const env = {
+		...process.env,
+		[ENV.QQ_PATH]: options.qq.qqPath,
+		[ENV.KERNEL_ENTRY]: resolve(options.kernelEntry),
+		[ENV.CFG_DIR]: cfg,
+		[ENV.QQ_VERSION]: options.qq.version,
+		[ENV.WRAPPER_PATH]: options.qq.wrapperPath
+	};
+	if (options.selfHost === true) env[ENV.SELF_HOST] = "1";
+	if (options.adapterEntry !== void 0) env[ENV.ADAPTER_ENTRY] = resolve(options.adapterEntry);
+	if (options.networkEntry !== void 0) env[ENV.NETWORK_ENTRY] = resolve(options.networkEntry);
+	if (options.configPath !== void 0) env[ENV.CONFIG_PATH] = resolve(options.configPath);
+	if (options.quickUin !== void 0) env[ENV.QUICK_UIN] = options.quickUin;
+	return env;
+}
+/** 环境变量名（self-host.cjs 与 kernel 引导读取）。 */
+const ENV = {
+	QQ_PATH: "NAPUTO_QQ_PATH",
+	KERNEL_ENTRY: "NAPUTO_KERNEL_ENTRY",
+	CFG_DIR: "NAPUTO_CFG_DIR",
+	QQ_VERSION: "NAPUTO_QQ_VERSION",
+	WRAPPER_PATH: "NAPUTO_WRAPPER_PATH",
+	/** 自建宿主：标准 node + stub QQNT.dll 引导（self-host.cjs 分支）。 */
+	SELF_HOST: "NAPUTO_SELF_HOST",
+	/** stub QQNT.dll 目录（launchSelfHost 注入，self-host.cjs 诊断用）。 */
+	STUB_DIR: "NAPUTO_STUB_DIR",
+	/** adapter 包入口（协议装配用）。 */
+	ADAPTER_ENTRY: "NAPUTO_ADAPTER_ENTRY",
+	/** network 包入口（协议装配用）。 */
+	NETWORK_ENTRY: "NAPUTO_NETWORK_ENTRY",
+	/** 全局配置文件路径（项目根 napuketto.toml，boot-protocols 读取）。 */
+	CONFIG_PATH: "NAPKETTO_CONFIG",
+	/** 强制指定快速登录账号（cli `-q <uin>` 透传，bootstrap 登录用）。 */
+	QUICK_UIN: "NAPUTO_QUICK_UIN"
+};
+//#endregion
+//#region src/locate-qq.ts
+/**
+* 定位 QQ 安装目录与版本（复用 kernel wrapper-version 的探测逻辑）
+*/
+/** 注册表 UninstallString 查询（QQ 官方安装路径）。 */
+const REG_QUERY_RE = /"([^"]+)"/;
+/** 注册表 UninstallString 查询（QQ 官方安装路径）。 */
+function findQqViaRegistry() {
+	try {
+		const exe = execFileSync("reg", [
+			"query",
+			"HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\QQ",
+			"/v",
+			"UninstallString"
+		]).toString().match(REG_QUERY_RE)?.[1];
+		if (exe !== void 0) {
+			const dir = exe.replaceAll("\"", "").slice(0, exe.lastIndexOf("\\"));
+			const qq = join(dir, "QQ.exe");
+			if (existsSync(qq)) return qq;
+		}
+	} catch {}
+	return null;
+}
+/** 常见安装路径探测。 */
+function findQqViaCommonPaths() {
+	const localAppData = process.env["LOCALAPPDATA"] ?? "";
+	const candidates = [
+		"C:/Program Files/Tencent/QQNT/QQ.exe",
+		"C:/Program Files (x86)/Tencent/QQNT/QQ.exe",
+		join(localAppData, "Programs", "Tencent", "QQNT", "QQ.exe"),
+		"C:/Dev/QQBot-Dev/QQNT/QQ.exe"
+	];
+	for (const p of candidates) if (existsSync(p)) return p;
+	return null;
+}
+/** 找 QQ.exe 路径。 */
+function locateQqPath() {
+	const viaReg = findQqViaRegistry();
+	if (viaReg) return viaReg;
+	const viaCommon = findQqViaCommonPaths();
+	if (viaCommon) return viaCommon;
+	throw new Error("未找到 QQ.exe（请先安装 QQ，或通过 NAPUTO_QQ_PATH 指定）");
+}
+/** 从 QQ.exe 路径推导安装目录，并探测当前版本。 */
+function resolveQqInstall(qqPath) {
+	const qq = qqPath ?? process.env["NAPUTO_QQ_PATH"] ?? locateQqPath();
+	const installDir = qq.slice(0, qq.lastIndexOf("\\"));
+	const versionsDir = join(installDir, "versions");
+	if (!existsSync(versionsDir)) throw new Error(`QQ 版本目录不存在: ${versionsDir}`);
+	const [first] = readdirSync(versionsDir).filter((v) => statSync(join(versionsDir, v)).isDirectory()).sort().reverse();
+	if (first === void 0) throw new Error(`QQ 版本目录为空: ${versionsDir}`);
+	const wrapperPath = join(versionsDir, first, "resources", "app", "wrapper.node");
+	if (!existsSync(wrapperPath)) throw new Error(`未找到 wrapper.node: ${wrapperPath}`);
+	return {
+		qqPath: qq,
+		installDir,
+		version: first,
+		wrapperPath
+	};
+}
+//#endregion
+export { ENV, defaultStubDir, launchSelfHost, locateQqPath, resolveQqInstall };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/launcher.ts","../src/locate-qq.ts"],"sourcesContent":["/**\n * launcher：自建宿主引导（2026-08-07 唯一路线）——spawn 标准 node 跑 self-host.cjs。\n *\n * 历史（V1/路线 B 事实链，已归档 archive/）：\n *  1. wrapper.node 只能在 QQ 定制版 Electron 里注册（实测纯 Node/普通 Electron 均 self-register 失败）\n *  2. QQ 是打包应用，禁 NODE_OPTIONS（实测 stderr）\n *  → 旧方案：NapukettoBootMain.exe 启动 QQ + 注入 NapukettoWinBootHook.dll（已废弃）\n *  → 现方案：stub QQNT.dll 转发宿主符号 → 标准 node 直接 dlopen wrapper.node（自建宿主）\n */\nimport { type StdioOptions, spawn } from \"node:child_process\";\nimport { existsSync, mkdirSync } from \"node:fs\";\nimport { dirname, join, resolve } from \"node:path\";\nimport process from \"node:process\";\nimport { fileURLToPath } from \"node:url\";\nimport type { QqInstallInfo } from \"./locate-qq.js\";\n\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n\nexport interface LaunchOptions {\n    /** QQ 安装信息（qqPath/version/wrapperPath）。 */\n    qq: QqInstallInfo;\n    /** kernel 入口（.mjs，self-host.cjs 里 import）。 */\n    kernelEntry: string;\n    /** 配置目录（账号数据目录，NAPUTO_CFG_DIR）。 */\n    cfgDir: string;\n    /** 全局配置文件路径（项目根 napuketto.toml，注入 NAPKETTO_CONFIG 供装配链读取）。 */\n    configPath?: string;\n    /** adapter 入口（.mjs，协议装配用）。 */\n    adapterEntry?: string;\n    /** network 入口（.mjs，协议装配用）。 */\n    networkEntry?: string;\n    /** 自建宿主：标准 node + stub QQNT.dll 直接引导，不拉起 QQ（2026-08-07 唯一路线）。 */\n    selfHost?: boolean;\n    /** stub QQNT.dll 目录（PATH 前置，转发 napi_*、uv_* 符号到 node.exe）。 */\n    stubDir?: string;\n    /** 强制指定快速登录账号（注入 NAPUTO_QUICK_UIN；cli `-q <uin>` 透传，2026-08-07）。 */\n    quickUin?: string;\n    /** 自建宿主入口（默认 dist/host/self-host.cjs）。 */\n    selfHostEntry?: string;\n    /**\n     * 子进程工作目录（缺省继承父进程 cwd）。\n     *\n     * ⚠️ 必须指向数据根（~/.napuketto）：QQ 原生层在账号上下文就绪前会\n     * fallback 到进程 cwd 落盘（如频道库 guild1.db），不指定则污染调用方\n     * 目录（实测写入项目根，guild1.db 08-07）。cli 传 dataRoot 根治。\n     */\n    cwd?: string;\n    /**\n     * 子进程 stdio（默认 \"inherit\"）。cli 传 [\"inherit\",\"pipe\",\"pipe\"] 并接管\n     * 子进程 stdout/stderr：逐行过滤 wrapper 原生噪音（MMKV 刷屏、Node 符号\n     * 查找失败警告），其余转发——原生 printf 直写 fd 的字节无法从 JS 层拦截。\n     */\n    stdio?: StdioOptions;\n}\n\nexport interface LaunchResult {\n    /** 子进程句柄（自建宿主 node 进程）。 */\n    child: ReturnType<typeof spawn>;\n    /** 自建宿主入口路径（self-host.cjs）。 */\n    bootJsPath: string;\n}\n\n/**\n * 启动自建宿主（路线 A，2026-08-07 产品化）：spawn 标准 node 直接跑 self-host.cjs，\n * 不拉起 QQ / 不注入。\n *\n * 关键（HANDOVER-V7 技术数据）：wrapper.node 从 QQNT.dll 导入 99 符号\n * （napi_*×40 + uv_*×56 + qq_magic×1 + v8/node mangled×2）——标准 node 无这些宿主\n * 符号，必须 PATH 前置 stub QQNT.dll 目录（转发到 node.exe）+ QQ resources\\app\n * （wrapper.node 同目录依赖 DLL）才能 dlopen 成功。\n */\nexport function launchSelfHost(options: LaunchOptions): LaunchResult {\n    const selfHostPath =\n        options.selfHostEntry ?? join(__dirname, \"..\", \"dist\", \"host\", \"self-host.cjs\");\n    if (!existsSync(selfHostPath)) {\n        throw new Error(\n            `self-host.cjs 缺失: ${selfHostPath}（先运行 pnpm --filter @napuketto/loader build）`,\n        );\n    }\n\n    // stub QQNT.dll 校验（自建宿主必需：PATH 前置 stub 转发 napi_* 到 node.exe，\n    // 否则 wrapper.node dlopen 失败）。默认 loader 包内闭源 submodule native/stub-test-env，\n    // 缺失时提示 --stub-dir / NAPUTO_STUB_DIR 指定。\n    const stub = options.stubDir ?? defaultStubDir();\n    if (!existsSync(join(stub, \"QQNT.dll\"))) {\n        throw new Error(\n            `stub QQNT.dll 未找到: ${stub}（自建宿主必需：stub 转发 QQNT.dll 符号到 node.exe；` +\n                \"请用 --stub-dir 或环境变量 NAPUTO_STUB_DIR 指定 stub 目录）\",\n        );\n    }\n\n    const env = buildLaunchEnv(options);\n    // PATH 前置 stub 目录（stub QQNT.dll 转发）+ QQ resources\\app（wrapper.node 依赖 DLL）\n    const pathEntries = [stub, dirname(options.qq.wrapperPath), process.env[\"PATH\"] ?? \"\"]\n        .filter((p) => p !== undefined && p !== \"\")\n        .join(\";\");\n    env[\"PATH\"] = pathEntries;\n    env[ENV.STUB_DIR] = stub;\n\n    // 标准 node 直接跑入口（不拉起 QQ，不注入）\n    // cwd 显式指向数据根（cli 传入）：QQ 原生层 fallback 落盘（guild1.db 等）\n    // 不再污染项目根目录（实测 08-07，GPro 模块初始化早于账号上下文）。\n    if (options.cwd !== undefined) {\n        mkdirSync(options.cwd, { recursive: true });\n    }\n    const child = spawn(process.execPath, [selfHostPath], {\n        // exactOptionalPropertyTypes：未传 cwd 时不显式写入 undefined（继承父进程）\n        ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),\n        env,\n        stdio: options.stdio ?? \"inherit\",\n        windowsHide: false,\n    });\n\n    return { child, bootJsPath: selfHostPath };\n}\n\n/**\n * 默认 stub QQNT.dll 目录（loader 包内闭源 native/build/stub-test-env，开发机默认）。\n * src 与 native 同层，构建后 dist 与 native 同层——`../native` 恒正确。\n */\nexport function defaultStubDir(): string {\n    return join(__dirname, \"..\", \"native\", \"build\", \"stub-test-env\");\n}\n\n/** 装配自建宿主环境变量。 */\nfunction buildLaunchEnv(options: LaunchOptions): Record<string, string> {\n    // 配置目录兜底\n    const cfg = resolve(options.cfgDir);\n    mkdirSync(cfg, { recursive: true });\n\n    const env: Record<string, string> = {\n        ...process.env,\n        [ENV.QQ_PATH]: options.qq.qqPath,\n        [ENV.KERNEL_ENTRY]: resolve(options.kernelEntry),\n        [ENV.CFG_DIR]: cfg,\n        [ENV.QQ_VERSION]: options.qq.version,\n        [ENV.WRAPPER_PATH]: options.qq.wrapperPath,\n    };\n    if (options.selfHost === true) {\n        env[ENV.SELF_HOST] = \"1\";\n    }\n    if (options.adapterEntry !== undefined) {\n        env[ENV.ADAPTER_ENTRY] = resolve(options.adapterEntry);\n    }\n    if (options.networkEntry !== undefined) {\n        env[ENV.NETWORK_ENTRY] = resolve(options.networkEntry);\n    }\n    if (options.configPath !== undefined) {\n        env[ENV.CONFIG_PATH] = resolve(options.configPath);\n    }\n    if (options.quickUin !== undefined) {\n        env[ENV.QUICK_UIN] = options.quickUin;\n    }\n    return env;\n}\n\n/** 环境变量名（self-host.cjs 与 kernel 引导读取）。 */\nexport const ENV = {\n    QQ_PATH: \"NAPUTO_QQ_PATH\",\n    KERNEL_ENTRY: \"NAPUTO_KERNEL_ENTRY\",\n    CFG_DIR: \"NAPUTO_CFG_DIR\",\n    QQ_VERSION: \"NAPUTO_QQ_VERSION\",\n    WRAPPER_PATH: \"NAPUTO_WRAPPER_PATH\",\n    /** 自建宿主：标准 node + stub QQNT.dll 引导（self-host.cjs 分支）。 */\n    SELF_HOST: \"NAPUTO_SELF_HOST\",\n    /** stub QQNT.dll 目录（launchSelfHost 注入，self-host.cjs 诊断用）。 */\n    STUB_DIR: \"NAPUTO_STUB_DIR\",\n    /** adapter 包入口（协议装配用）。 */\n    ADAPTER_ENTRY: \"NAPUTO_ADAPTER_ENTRY\",\n    /** network 包入口（协议装配用）。 */\n    NETWORK_ENTRY: \"NAPUTO_NETWORK_ENTRY\",\n    /** 全局配置文件路径（项目根 napuketto.toml，boot-protocols 读取）。 */\n    CONFIG_PATH: \"NAPKETTO_CONFIG\",\n    /** 强制指定快速登录账号（cli `-q <uin>` 透传，bootstrap 登录用）。 */\n    QUICK_UIN: \"NAPUTO_QUICK_UIN\",\n} as const;\n","/**\n * 定位 QQ 安装目录与版本（复用 kernel wrapper-version 的探测逻辑）\n */\nimport { execFileSync } from \"node:child_process\";\nimport { existsSync, readdirSync, statSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport process from \"node:process\";\n\n/** 注册表 UninstallString 查询（QQ 官方安装路径）。 */\nconst REG_QUERY_RE = /\"([^\"]+)\"/;\n\n/** 注册表 UninstallString 查询（QQ 官方安装路径）。 */\nfunction findQqViaRegistry(): string | null {\n    try {\n        const out = execFileSync(\"reg\", [\n            \"query\",\n            \"HKLM\\\\SOFTWARE\\\\WOW6432Node\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Uninstall\\\\QQ\",\n            \"/v\",\n            \"UninstallString\",\n        ]).toString();\n        const m = out.match(REG_QUERY_RE);\n        const exe = m?.[1];\n        if (exe !== undefined) {\n            // UninstallString 形如 \"C:\\...\\uninst.exe\" 或带参数\n            const dir = exe.replaceAll('\"', \"\").slice(0, exe.lastIndexOf(\"\\\\\"));\n            const qq = join(dir, \"QQ.exe\");\n            if (existsSync(qq)) {\n                return qq;\n            }\n        }\n    } catch {\n        // 注册表查询失败，走常见路径\n    }\n    return null;\n}\n\n/** 常见安装路径探测。 */\nfunction findQqViaCommonPaths(): string | null {\n    const localAppData = process.env[\"LOCALAPPDATA\"] ?? \"\";\n    const candidates = [\n        \"C:/Program Files/Tencent/QQNT/QQ.exe\",\n        \"C:/Program Files (x86)/Tencent/QQNT/QQ.exe\",\n        join(localAppData, \"Programs\", \"Tencent\", \"QQNT\", \"QQ.exe\"),\n        // 开发机目录（2026-08-07 环境事实：QQ 9.9.33-51802 在 C:\\Dev\\QQBot-Dev\\QQNT）\n        \"C:/Dev/QQBot-Dev/QQNT/QQ.exe\",\n    ];\n    for (const p of candidates) {\n        if (existsSync(p)) {\n            return p;\n        }\n    }\n    return null;\n}\n\n/** QQ 安装目录探测结果。 */\nexport interface QqInstallInfo {\n    /** QQ.exe 绝对路径。 */\n    qqPath: string;\n    /** 安装根目录。 */\n    installDir: string;\n    /** 当前版本目录名（如 9.9.31-49919）。 */\n    version: string;\n    /** wrapper.node 绝对路径。 */\n    wrapperPath: string;\n}\n\n/** 找 QQ.exe 路径。 */\nexport function locateQqPath(): string {\n    const viaReg = findQqViaRegistry();\n    if (viaReg) {\n        return viaReg;\n    }\n    const viaCommon = findQqViaCommonPaths();\n    if (viaCommon) {\n        return viaCommon;\n    }\n    throw new Error(\"未找到 QQ.exe（请先安装 QQ，或通过 NAPUTO_QQ_PATH 指定）\");\n}\n\n/** 从 QQ.exe 路径推导安装目录，并探测当前版本。 */\nexport function resolveQqInstall(qqPath?: string): QqInstallInfo {\n    const qq = qqPath ?? process.env[\"NAPUTO_QQ_PATH\"] ?? locateQqPath();\n    const installDir = qq.slice(0, qq.lastIndexOf(\"\\\\\"));\n    const versionsDir = join(installDir, \"versions\");\n    if (!existsSync(versionsDir)) {\n        throw new Error(`QQ 版本目录不存在: ${versionsDir}`);\n    }\n    const versions = readdirSync(versionsDir)\n        .filter((v) => statSync(join(versionsDir, v)).isDirectory())\n        .sort()\n        .reverse();\n    const [first] = versions;\n    if (first === undefined) {\n        throw new Error(`QQ 版本目录为空: ${versionsDir}`);\n    }\n    const wrapperPath = join(versionsDir, first, \"resources\", \"app\", \"wrapper.node\");\n    if (!existsSync(wrapperPath)) {\n        throw new Error(`未找到 wrapper.node: ${wrapperPath}`);\n    }\n    return { qqPath: qq, installDir, version: first, wrapperPath };\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@napuketto/loader",
+  "version": "0.0.1",
+  "description": "NapukettoQQ 引导组件：自建宿主（标准 Node + stub QQNT.dll）dlopen wrapper.node 并启动 kernel，不拉起 QQ / 不注入",
+  "type": "module",
+  "files": [
+    "dist",
+    "native/build/stub-test-env"
+  ],
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsdown": "^0.22.14"
+  },
+  "license": "MIT",
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown"
+  }
+}