@jixoai/gh-runner 0.0.0 → 0.2.0

package/dist/main.mjs

@@ -0,0 +1,1656 @@
+#!/usr/bin/env node
+import { arch, homedir, platform } from "node:os";
+import { mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { createTray } from "opentray";
+import { attachDialog } from "@opentray/ext-dialog";
+import { dirname, isAbsolute, join } from "node:path";
+import { createWriteStream, existsSync } from "node:fs";
+import { promisify } from "node:util";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
+import { WebviewExt } from "@opentray/ext-webview";
+// src/tailer.ts
+/**
+* 跟随一个目录中最新的、名字匹配 `prefix*.log` 的文件。
+* - 文件被轮转（出现更新者）时切换并从尾部起步；
+* - 文件被截断时重置 offset；
+* - start() 首次把既有尾部内容以回调交付（用于恢复状态），此后持续增量。
+*/
+var DirTail = class {
+	#dir;
+	#prefix;
+	#intervalMs;
+	#initialBackreadBytes;
+	#timer = null;
+	#activeFile = null;
+	#offset = 0;
+	#partial = "";
+	/** 首附/轮转从文件中部（64KB 窗口）起步时，首个片段是残行，须丢弃到首个换行。 */
+	#skipFirstPartial = false;
+	#polling = false;
+	constructor(dir, prefix, options = {}) {
+		this.#dir = dir;
+		this.#prefix = prefix;
+		this.#intervalMs = options.intervalMs ?? 1e3;
+		this.#initialBackreadBytes = options.initialBackreadBytes ?? 65536;
+	}
+	start(onLines) {
+		if (this.#timer) return;
+		this.#poll(onLines);
+		this.#timer = setInterval(() => void this.#poll(onLines), this.#intervalMs);
+		this.#timer.unref?.();
+	}
+	stop() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = null;
+		this.#activeFile = null;
+		this.#offset = 0;
+		this.#partial = "";
+	}
+	async #listCandidates() {
+		let names;
+		try {
+			names = await readdir(this.#dir);
+		} catch {
+			return [];
+		}
+		const matched = names.filter((n) => n.startsWith(this.#prefix) && n.endsWith(".log"));
+		const out = [];
+		for (const name of matched) try {
+			const st = await stat(join(this.#dir, name));
+			if (st.isFile()) out.push({
+				file: name,
+				mtimeMs: st.mtimeMs
+			});
+		} catch {}
+		out.sort((a, b) => a.mtimeMs === b.mtimeMs ? a.file < b.file ? 1 : -1 : b.mtimeMs - a.mtimeMs);
+		return out;
+	}
+	async #poll(onLines) {
+		if (this.#polling) return;
+		this.#polling = true;
+		try {
+			const latest = (await this.#listCandidates())[0];
+			if (!latest) {
+				this.#activeFile = null;
+				return;
+			}
+			const path = join(this.#dir, latest.file);
+			if (this.#activeFile !== path) {
+				const st = await stat(path);
+				const start = Math.max(0, st.size - this.#initialBackreadBytes);
+				this.#activeFile = path;
+				this.#offset = start;
+				this.#partial = "";
+				this.#skipFirstPartial = start > 0;
+			}
+			const st = await stat(path).catch(() => null);
+			if (!st) return;
+			if (st.size < this.#offset) {
+				this.#offset = 0;
+				this.#partial = "";
+			}
+			if (st.size === this.#offset) return;
+			const handle = await open(path, "r");
+			try {
+				const length = st.size - this.#offset;
+				const buffer = Buffer.alloc(length);
+				await handle.read(buffer, 0, length, this.#offset);
+				this.#offset = st.size;
+				let text = this.#partial + buffer.toString("utf8");
+				if (this.#skipFirstPartial) {
+					const firstNl = text.indexOf("\n");
+					text = firstNl >= 0 ? text.slice(firstNl + 1) : "";
+					this.#skipFirstPartial = false;
+				}
+				const lines = text.split("\n");
+				this.#partial = lines.pop() ?? "";
+				const complete = lines.filter((l) => l.trim().length > 0);
+				if (complete.length > 0) onLines(complete);
+			} finally {
+				await handle.close();
+			}
+		} catch {} finally {
+			this.#polling = false;
+		}
+	}
+};
+// src/logparse.ts
+/** 日志行前缀（diag 文件形态）：`[2026-10-24 10:16:04Z INFO Terminal] WRITE LINE: `。 */
+const DIAG_PREFIX = "] WRITE LINE: ";
+const ANSI$1 = /\x1b\[[0-9;]*m/g;
+const TS = "([0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2})";
+const RE_RUNNING = new RegExp(`^${TS}Z: Running job: (.+)$`);
+const RE_COMPLETED = new RegExp(`^${TS}Z: Job (.+) completed with result: (.+)$`);
+const RE_LISTENING = new RegExp(`^${TS}Z: Listening for Jobs$`);
+/** `2026-10-24 10:16:04` → `2026-10-24T10:16:04Z`（runner 控制台时间戳恒为 UTC）。 */
+function toIsoUtc(raw) {
+	return `${raw.replace(" ", "T")}Z`;
+}
+/** 剥离 diag 包裹前缀（`[..INFO Terminal] WRITE LINE: `），非包裹行原样返回。 */
+function stripDiagPrefix(line) {
+	const marker = line.indexOf(DIAG_PREFIX);
+	return marker >= 0 ? line.slice(marker + 14) : line;
+}
+/** 剥离 diag 包裹与 ANSI 颜色，还原纯控制台行；非控制台行返回 null。 */
+function normalizeLine(line) {
+	const stripped = stripDiagPrefix(line).replaceAll(ANSI$1, "").trimEnd();
+	return RE_LISTENING.test(stripped) || RE_RUNNING.test(stripped) || RE_COMPLETED.test(stripped) ? stripped : null;
+}
+/** 解析一行控制台输出；不是作业事件行时返回 null。 */
+function parseConsoleLine(line) {
+	const content = normalizeLine(line);
+	if (content === null) return null;
+	const completed = RE_COMPLETED.exec(content);
+	if (completed) return {
+		at: toIsoUtc(completed[1]),
+		kind: "job-end",
+		job: completed[2],
+		outcome: completed[3].trim()
+	};
+	const running = RE_RUNNING.exec(content);
+	if (running) return {
+		at: toIsoUtc(running[1]),
+		kind: "job-start",
+		job: running[2].trim()
+	};
+	const listening = RE_LISTENING.exec(content);
+	if (listening) return {
+		at: toIsoUtc(listening[1]),
+		kind: "idle"
+	};
+	return null;
+}
+// src/platform.ts
+const IS_WIN = platform() === "win32";
+const PLATFORM = platform();
+const ARCH = arch();
+/** actions/runner release 资产的平台段：darwin→osx, win32→win, linux→linux。 */
+function osSegment(p = PLATFORM) {
+	if (p === "darwin") return "osx";
+	if (p === "win32") return "win";
+	return "linux";
+}
+/** arch 段：ia32→x86, arm64→arm64, 其余→x64。 */
+function archSegment(a = ARCH) {
+	if (a === "ia32") return "x86";
+	if (a === "arm64") return "arm64";
+	return "x64";
+}
+/** 官方 release 资产名，如 actions-runner-osx-arm64-2.338.1.tar.gz / actions-runner-win-x64-2.338.1.zip。 */
+function assetNameFor(version, p = PLATFORM, a = ARCH) {
+	const ext = osSegment(p) === "win" ? "zip" : "tar.gz";
+	return `actions-runner-${osSegment(p)}-${archSegment(a)}-${version}.${ext}`;
+}
+/** 包文件是否与当前平台匹配（供 UI 把不兼容包置灰）。 */
+function packageCompatible(fileName) {
+	const seg = `${osSegment()}-${archSegment()}`;
+	return fileName.includes(`-${seg}-`);
+}
+/** runner 启动入口：darwin/linux 用 run.sh；win32 直接跑 Listener.exe（run.cmd 只是它的薄包装）。 */
+function runnerSpawn(dir) {
+	if (IS_WIN) return {
+		file: join(dir, "bin", "Runner.Listener.exe"),
+		args: ["run"]
+	};
+	return {
+		file: join(dir, "run.sh"),
+		args: []
+	};
+}
+/** 注册命令：darwin/linux 走 ./config.sh；win32 用 Listener 的 configure 动词（避免 cmd.exe 转义坑）。 */
+function registerSpawn(dir) {
+	if (IS_WIN) return {
+		file: join(dir, "bin", "Runner.Listener.exe"),
+		prefixArgs: ["configure"]
+	};
+	return {
+		file: "./config.sh",
+		prefixArgs: []
+	};
+}
+/** labels 默认值（UI 预填）。 */
+function defaultLabels() {
+	if (PLATFORM === "darwin") return "self-hosted,macOS,ARM64";
+	if (IS_WIN) return `self-hosted,Windows,${archSegment().toUpperCase()}`;
+	return `self-hosted,Linux,${archSegment().toUpperCase()}`;
+}
+/** 实例目录的默认父目录（UI placeholder 与初始 searchDirs）。 */
+function defaultSearchDirs() {
+	if (PLATFORM === "darwin") return ["/Volumes/bnqkl/Users/kzf"];
+	if (IS_WIN) return ["C:\\actions-runner", homedir()];
+	return [homedir()];
+}
+/** 在系统文件管理器中揭示目录/文件。 */
+function revealInFileManager(path) {
+	if (PLATFORM === "darwin") return {
+		file: "open",
+		args: ["-R", path]
+	};
+	if (IS_WIN) return {
+		file: "explorer",
+		args: [`/select,${path}`]
+	};
+	return {
+		file: "xdg-open",
+		args: [path]
+	};
+}
+/** 平台路径分段（win32 反斜杠）。 */
+function basenameOf(dir) {
+	const parts = dir.split(/[\\/]+/).filter(Boolean);
+	return parts[parts.length - 1] ?? dir;
+}
+/** 平台无关的绝对路径判定。 */
+function isAbsolutePath(p) {
+	if (IS_WIN) return /^[A-Za-z]:[\\/]/.test(p) || isAbsolute(p);
+	return isAbsolute(p);
+}
+// src/discover.ts
+const exec = promisify(execFile);
+/** 读取 <dir>/.runner；缺失或损坏时返回未配置态。注意 GitHub 写入的文件带 UTF-8 BOM。 */
+async function readRunnerMeta(dir) {
+	try {
+		const raw = (await readFile(join(dir, ".runner"), "utf8")).replace(/^\uFEFF/, "");
+		const json = JSON.parse(raw);
+		return {
+			agentId: typeof json.agentId === "number" ? json.agentId : null,
+			agentName: json.agentName ?? null,
+			gitHubUrl: json.gitHubUrl ?? null,
+			workFolder: json.workFolder ?? null,
+			configured: true
+		};
+	} catch {
+		return {
+			agentId: null,
+			agentName: null,
+			gitHubUrl: null,
+			workFolder: null,
+			configured: false
+		};
+	}
+}
+/** 扫描父目录集合，返回含 .runner 的一层子目录（绝对路径）。 */
+async function discoverRunnerDirs(searchDirs) {
+	const found = [];
+	for (const parent of searchDirs) {
+		let names;
+		try {
+			names = (await readdir(parent, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+		} catch {
+			continue;
+		}
+		for (const name of names) {
+			const dir = join(parent, name);
+			try {
+				await readFile(join(dir, ".runner"), "utf8");
+				found.push(dir);
+			} catch {}
+		}
+	}
+	return found.sort();
+}
+/**
+* 全部 Runner.Listener 进程 → pid 身份（darwin/linux = cwd；win32 = 由 ExecutablePath 推导的
+* runner 目录）。身份与实例目录对账。
+*/
+async function findListenerProcesses() {
+	if (IS_WIN) {
+		const result = /* @__PURE__ */ new Map();
+		try {
+			const { stdout } = await exec("powershell", [
+				"-NoProfile",
+				"-Command",
+				`Get-CimInstance Win32_Process -Filter "Name='Runner.Listener.exe'" | ForEach-Object { "$($_.ProcessId)|$($_.ExecutablePath)" }`
+			], { timeout: 15e3 });
+			for (const line of stdout.split(/\r?\n/)) {
+				const m = /^(\d+)\|(.+)$/.exec(line.trim());
+				if (!m) continue;
+				result.set(Number(m[1]), dirname(dirname(m[2])));
+			}
+		} catch {}
+		return result;
+	}
+	const result = /* @__PURE__ */ new Map();
+	try {
+		const { stdout } = await exec("pgrep", ["-f", "Runner.Listener run"]);
+		const pids = stdout.split("\n").map((s) => Number.parseInt(s.trim(), 10)).filter((n) => Number.isInteger(n) && n > 0);
+		await Promise.all(pids.map(async (pid) => {
+			try {
+				const { stdout: out } = await exec("lsof", [
+					"-a",
+					"-p",
+					String(pid),
+					"-d",
+					"cwd",
+					"-Fn"
+				]);
+				for (const line of out.split("\n")) if (line.startsWith("n/")) {
+					const raw = line.slice(1);
+					result.set(pid, await realpath(raw).catch(() => raw));
+				}
+			} catch {}
+		}));
+	} catch {}
+	return result;
+}
+/** 实例默认 id：目录名。 */
+function instanceIdOf(dir, _cfg) {
+	const parts = dir.split(/[\\/]+/).filter(Boolean);
+	return parts[parts.length - 1] ?? dir;
+}
+/** 单个 pid 的身份（同 findListenerProcesses 口径；读不到返回 null）。供停止前的 pid 复用核验。 */
+async function pidIdentity(pid) {
+	return (await findListenerProcesses()).get(pid) ?? null;
+}
+// src/supervisor.ts
+const ANSI = /\x1b\[[0-9;]*m/g;
+function stripAnsi(line) {
+	return line.replaceAll(ANSI, "").trimEnd();
+}
+function splitLines(chunk) {
+	return chunk.split(/\r?\n/).filter((l) => l.trim().length > 0);
+}
+/**
+* 拉起 <dir>/run.sh（detached：随工具退出继续存活，与"终端里跑"等价）。
+* 返回 null 表示 run.sh 不存在或无法 spawn（权限/解释器缺失——错误细节经 onLine(stderr) 回流）。
+*/
+function startRunner(dir, onLine, onError) {
+	const entry = runnerSpawn(dir);
+	if (!(IS_WIN ? existsSync(entry.file) : existsSync(join(dir, "run.sh")))) return null;
+	const child = IS_WIN ? spawn(entry.file, entry.args, {
+		cwd: dir,
+		detached: true,
+		windowsHide: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		env: { ...process.env }
+	}) : spawn(entry.file, entry.args, {
+		cwd: dir,
+		detached: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		env: {
+			...process.env,
+			RUNNER_MANUALLY_TRAP_SIG: "1"
+		}
+	});
+	child.on("error", (err) => {
+		onError?.(err);
+		onLine("stderr", `[spawn error] ${err.message}`);
+	});
+	if (child.pid == null) {
+		onLine("stderr", `[spawn error] 无法启动 run.sh（检查执行权限/解释器）`);
+		return null;
+	}
+	for (const stream of ["stdout", "stderr"]) {
+		child[stream].setEncoding("utf8");
+		child[stream].on("data", (chunk) => {
+			for (const line of splitLines(chunk)) onLine(stream, stripAnsi(line));
+		});
+	}
+	child.unref();
+	return {
+		pid: child.pid,
+		child
+	};
+}
+function pidExists(pid) {
+	try {
+		process.kill(pid, 0);
+		return "alive";
+	} catch (err) {
+		return err.code === "EPERM" ? "no-perm" : "dead";
+	}
+}
+/**
+* 终止：darwin/linux 对进程组 SIGTERM → 限时 SIGKILL；win32 用 taskkill /T（树终止），
+* 先宽限尝试再强制。返回 false 表示终止失败（进程未响应或无权限——EPERM 不算成功）。
+*/
+async function stopProcessGroup(pid, graceMs = 8e3) {
+	if (pidExists(pid) === "dead") return true;
+	if (IS_WIN) {
+		const tk = spawn("taskkill", [
+			"/pid",
+			String(pid),
+			"/T",
+			"/F"
+		], {
+			stdio: "ignore",
+			windowsHide: true
+		});
+		const ok = await new Promise((resolve) => {
+			tk.on("error", () => resolve(false));
+			tk.on("close", (code) => resolve(code === 0 || pidExists(pid) === "dead"));
+		});
+		const deadline = Date.now() + graceMs;
+		while (ok && Date.now() < deadline && pidExists(pid) !== "dead") await new Promise((r) => setTimeout(r, 250));
+		return pidExists(pid) === "dead";
+	}
+	const signal = (sig) => {
+		try {
+			process.kill(-pid, sig);
+			return true;
+		} catch {
+			try {
+				process.kill(pid, sig);
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	};
+	if (!signal("SIGTERM")) return false;
+	const deadline = Date.now() + graceMs;
+	while (Date.now() < deadline) {
+		await new Promise((r) => setTimeout(r, 250));
+		if (pidExists(pid) === "dead") return true;
+	}
+	if (!signal("SIGKILL")) return false;
+	await new Promise((r) => setTimeout(r, 500));
+	return pidExists(pid) === "dead";
+}
+// src/config.ts
+const DEFAULT_SEARCH_DIRS = defaultSearchDirs();
+function configDir() {
+	return join(homedir(), "Library", "Application Support", "gh-runner");
+}
+function configPath() {
+	return join(configDir(), "config.json");
+}
+/** 形状校验：损坏的实例项直接丢弃（手编配置/撕裂写的容错），不让 boot 崩掉。 */
+function validInstance(item) {
+	return typeof item === "object" && item !== null && typeof item.dir === "string" && item.dir.startsWith("/") && typeof item.id === "string";
+}
+async function loadConfig() {
+	try {
+		const raw = (await readFile(configPath(), "utf8")).replace(/^\uFEFF/, "");
+		const parsed = JSON.parse(raw);
+		const searchDirs = Array.isArray(parsed.searchDirs) ? parsed.searchDirs.filter((d) => typeof d === "string" && isAbsolutePath(d)) : [];
+		const instances = Array.isArray(parsed.instances) ? parsed.instances.filter((i) => validInstance(i)) : [];
+		const importedPackages = Array.isArray(parsed.importedPackages) ? parsed.importedPackages.filter((p) => typeof p === "string") : [];
+		return {
+			searchDirs: searchDirs.length > 0 ? searchDirs : DEFAULT_SEARCH_DIRS,
+			instances,
+			importedPackages
+		};
+	} catch {
+		return {
+			searchDirs: DEFAULT_SEARCH_DIRS,
+			instances: [],
+			importedPackages: []
+		};
+	}
+}
+/** 原子写：tmp + rename，杜绝撕裂写（损坏的 config 会 brick 启动路径）。 */
+async function saveConfig(config) {
+	await mkdir(configDir(), { recursive: true });
+	const path = configPath();
+	const tmp = `${path}.tmp`;
+	await writeFile(tmp, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	await rename(tmp, path);
+}
+function upsertInstance(config, instance) {
+	const rest = config.instances.filter((i) => i.id !== instance.id && i.dir !== instance.dir);
+	return {
+		...config,
+		instances: [...rest, instance]
+	};
+}
+// src/register.ts
+async function runStep(title, file, args, cwd, onProgress, timeoutMs = 3e5) {
+	onProgress(`$ ${title}`);
+	await new Promise((resolve, reject) => {
+		const child = spawn(file, args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const timer = setTimeout(() => {
+			child.kill("SIGKILL");
+			reject(/* @__PURE__ */ new Error(`${title} 超时（${timeoutMs / 1e3}s）`));
+		}, timeoutMs);
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		for (const stream of [child.stdout, child.stderr]) {
+			let partial = "";
+			stream.on("data", (chunk) => {
+				partial += chunk;
+				const lines = partial.split(/\r?\n/);
+				partial = lines.pop() ?? "";
+				for (const l of lines) if (l.trim()) onProgress(`  ${l.trim()}`);
+			});
+		}
+		child.on("error", (err) => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error(`${title} 启动失败: ${err.message}`));
+		});
+		child.on("close", (code) => {
+			clearTimeout(timer);
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`${title} 退出码 ${code}`));
+		});
+	});
+}
+/** 旧版回退：在 searchDirs 的约定位置（actions-runner/）探测既有分发包。 */
+async function findTarball(searchDirs) {
+	for (const parent of searchDirs) for (const sub of ["actions-runner", "."]) {
+		const dir = join(parent, sub);
+		try {
+			const hit = (await readdir(dir)).filter((n) => /^actions-runner-(osx|win|linux)-(x86|x64|arm64)-.*\.(tar\.gz|zip)$/.test(n)).sort().at(-1);
+			if (hit) return join(dir, hit);
+		} catch {}
+	}
+	return null;
+}
+async function registerRunner(req, searchDirs, onProgress) {
+	const dir = req.dir;
+	try {
+		if (!dir || !isAbsolutePath(dir)) throw new Error("实例目录必须是绝对路径");
+		if (!req.name.trim()) throw new Error("缺少实例名称");
+		if (!req.token.trim()) throw new Error("缺少注册 Token（org 设置页每次生成、一次性）");
+		if (!req.workFolder.trim()) throw new Error("缺少 Work 目录（多实例必须各自独立）");
+		let entries = [];
+		if (existsSync(dir)) {
+			entries = await readdir(dir);
+			if (entries.some((e) => e !== ".DS_Store")) throw new Error(`目录非空（${entries.length} 项）：注册必须是空目录；管理已有实例请直接 attach`);
+		} else {
+			onProgress(`创建目录 ${dir}`);
+			await mkdir(dir, { recursive: true });
+		}
+		const pkg = req.packagePath?.trim() ? req.packagePath.trim() : await findTarball(searchDirs);
+		if (!pkg || !existsSync(pkg)) throw new Error("未选定分发包：请下载最新版或导入本地包");
+		onProgress(`使用分发包 ${basenameOf(pkg)}`);
+		await runStep("解包分发包", "tar", ["-xf", pkg], dir, onProgress);
+		if (PLATFORM === "darwin") await runStep("移除 quarantine 隔离标记", "xattr", [
+			"-rd",
+			"com.apple.quarantine",
+			"."
+		], dir, onProgress);
+		const reg = registerSpawn(dir);
+		if (!existsSync(join(dir, reg.file.replace("./", ""))) && !IS_WIN) throw new Error("解包结果缺少 config.sh：包内容与预期不符");
+		await runStep(IS_WIN ? "Listener configure 注册" : "config.sh 注册", reg.file, [
+			...reg.prefixArgs,
+			"--url",
+			req.orgUrl.trim() || "https://github.com/jixoai",
+			"--token",
+			req.token.trim(),
+			"--name",
+			req.name.trim(),
+			"--labels",
+			req.labels.trim() || defaultLabels(),
+			"--work",
+			req.workFolder.trim(),
+			"--unattended"
+		], dir, onProgress);
+		const meta = await readRunnerMeta(dir);
+		if (!meta.configured) throw new Error("注册后未找到 .runner，注册疑似失败，请查看上方输出");
+		onProgress(`✔ 注册成功：${meta.agentName}（agentId=${meta.agentId}）`);
+		return {
+			ok: true,
+			error: null,
+			runnerDir: dir
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		onProgress(`✘ 注册失败：${message}`);
+		return {
+			ok: false,
+			error: message,
+			runnerDir: dir
+		};
+	}
+}
+// src/packages.ts
+/** 下载缓存目录（下载的包与导入清单都归工具所有）。 */
+function packagesDir() {
+	return join(configDir(), "packages");
+}
+const PKG_RE = /^actions-runner-(osx|win|linux)-(x86|x64|arm64)-\d+\.\d+\.\d+\.(tar\.gz|zip)$/;
+function toInfo(path, st) {
+	const name = path.split(/[\\/]+/).pop() ?? path;
+	return {
+		path,
+		name,
+		sizeBytes: st.size,
+		mtimeMs: st.mtimeMs,
+		compatible: packageCompatible(name)
+	};
+}
+/** 包清单：下载缓存目录里的包 + config 导入的外部路径（去重、新者在前）。 */
+async function listPackages(importedPaths) {
+	const out = /* @__PURE__ */ new Map();
+	const dir = packagesDir();
+	if (existsSync(dir)) for (const name of await readdir(dir)) {
+		const path = join(dir, name);
+		if (!PKG_RE.test(name)) continue;
+		try {
+			const st = await stat(path);
+			if (st.isFile()) out.set(path, toInfo(path, st));
+		} catch {}
+	}
+	for (const path of importedPaths) try {
+		const st = await stat(path);
+		if (st.isFile() && !out.has(path)) out.set(path, toInfo(path, st));
+	} catch {}
+	return [...out.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+/** 查询 actions/runner 最新 release 中匹配当前平台的资产。 */
+async function fetchLatestReleaseInfo() {
+	const res = await fetch("https://api.github.com/repos/actions/runner/releases/latest", { headers: {
+		"User-Agent": "jixoai-gh-runner",
+		Accept: "application/vnd.github+json"
+	} });
+	if (!res.ok) throw new Error(`GitHub API ${res.status}（查询最新 release 失败）`);
+	const body = await res.json();
+	const version = (body.tag_name ?? "").replace(/^v/, "");
+	if (!version || !Array.isArray(body.assets)) throw new Error("release 响应缺少 tag_name/assets");
+	const assetName = assetNameFor(version);
+	const asset = body.assets.find((a) => a.name === assetName);
+	if (!asset) throw new Error(`最新 release ${body.tag_name} 没有当前平台的资产（期望 ${assetName}）`);
+	return {
+		tag: body.tag_name,
+		version,
+		assetName,
+		url: asset.browser_download_url,
+		sizeBytes: asset.size
+	};
+}
+/** 流式下载到包缓存目录（tmp→rename 原子替换）；onProgress 以 0-100 汇报。 */
+async function downloadPackage(release, onProgress) {
+	await mkdir(packagesDir(), { recursive: true });
+	const dest = join(packagesDir(), release.assetName);
+	const tmp = `${dest}.part`;
+	await rm(tmp, { force: true });
+	const res = await fetch(release.url, {
+		headers: { "User-Agent": "jixoai-gh-runner" },
+		redirect: "follow"
+	});
+	if (!res.ok || !res.body) throw new Error(`下载失败：HTTP ${res.status}`);
+	const total = Number(res.headers.get("content-length") ?? release.sizeBytes) || release.sizeBytes;
+	let received = 0;
+	let lastPct = -1;
+	const source = Readable.fromWeb(res.body);
+	source.on("data", (chunk) => {
+		received += chunk.length;
+		const pct = total > 0 ? Math.min(100, Math.floor(received / total * 100)) : 0;
+		if (pct !== lastPct) {
+			lastPct = pct;
+			onProgress(pct, received, total);
+		}
+	});
+	await pipeline(source, createWriteStream(tmp));
+	if (total > 0 && received !== total) {
+		await rm(tmp, { force: true });
+		throw new Error(`下载不完整：${received}/${total} 字节`);
+	}
+	await rm(dest, { force: true });
+	await rename(tmp, dest);
+	return dest;
+}
+// src/fleet.ts
+const LOG_RING_MAX = 400;
+const DEDUP_MAX = 2400;
+const TICK_MS = 2e3;
+const DEBOUNCE_MS = 200;
+var Fleet = class {
+	#rts = /* @__PURE__ */ new Map();
+	#config = null;
+	#listeners = /* @__PURE__ */ new Set();
+	#seq = 0;
+	#dirty = false;
+	#debounceTimer = null;
+	#tickTimer = null;
+	#task = {
+		kind: "none",
+		status: "ok",
+		message: null
+	};
+	#ticking = false;
+	#persist = true;
+	#download = null;
+	#downloading = false;
+	async boot(options = {}) {
+		this.#persist = options.persist ?? true;
+		this.#config = await loadConfig();
+		await this.#syncInstances();
+		await this.#tick();
+		this.#tickTimer = setInterval(() => void this.#tick(), TICK_MS);
+		this.#tickTimer.unref?.();
+		if (options.autoStart ?? true) {
+			for (const rt of this.#rts.values()) if (rt.autoStart && rt.meta?.configured && rt.processState === "stopped") this.start(rt.id);
+		}
+	}
+	onSnapshot(listener) {
+		this.#listeners.add(listener);
+		listener(this.snapshot());
+		return () => this.#listeners.delete(listener);
+	}
+	snapshot() {
+		this.#seq += 1;
+		return {
+			seq: this.#seq,
+			now: (/* @__PURE__ */ new Date()).toISOString(),
+			platform: PLATFORM,
+			arch: ARCH,
+			instances: [...this.#rts.values()].map((rt) => this.#view(rt)).sort((a, b) => a.name.localeCompare(b.name)),
+			task: this.#task,
+			packages: this.#packages,
+			download: this.#download
+		};
+	}
+	#packages = [];
+	/** 刷新包清单（下载目录 ∪ 导入清单），变更时推送。 */
+	async #refreshPackages() {
+		try {
+			const before = JSON.stringify(this.#packages);
+			const stale = [];
+			this.#packages = await listPackages(this.#config?.importedPackages ?? []);
+			const paths = new Set(this.#packages.map((p) => p.path));
+			for (const imported of this.#config?.importedPackages ?? []) if (!paths.has(imported)) stale.push(imported);
+			if (stale.length > 0 && this.#config) {
+				this.#config.importedPackages = (this.#config.importedPackages ?? []).filter((p) => !stale.includes(p));
+				if (this.#persist) await saveConfig(this.#config);
+			}
+			if (JSON.stringify(this.#packages) !== before) this.#emitSoon();
+		} catch {}
+	}
+	/** 下载 actions/runner 最新平台的包（进度写入 snapshot.download，完成后刷新清单）。 */
+	async downloadLatest() {
+		if (this.#downloading) return;
+		this.#downloading = true;
+		this.#download = {
+			status: "running",
+			pct: 0,
+			message: "查询最新 release…"
+		};
+		this.#emitSoon();
+		try {
+			const release = await fetchLatestReleaseInfo();
+			this.#download = {
+				status: "running",
+				pct: 0,
+				message: `下载 ${release.assetName}`
+			};
+			this.#emitSoon();
+			const dest = await downloadPackage(release, (pct) => {
+				this.#download = {
+					status: "running",
+					pct,
+					message: `下载 ${release.assetName}`
+				};
+				this.#emitSoon();
+			});
+			this.#download = {
+				status: "ok",
+				pct: 100,
+				message: `已下载 ${dest}`
+			};
+			await this.#refreshPackages();
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this.#download = {
+				status: "error",
+				pct: 0,
+				message
+			};
+		} finally {
+			this.#downloading = false;
+			this.#emitSoon();
+			setTimeout(() => {
+				if (this.#download && this.#download.status !== "running") {
+					this.#download = null;
+					this.#emitSoon();
+				}
+			}, 8e3).unref?.();
+		}
+	}
+	/** 通过系统文件选择对话框导入本地包路径（登记进 config，不复制）。 */
+	async importPackage(path) {
+		if (!this.#config || !isAbsolutePath(path)) return;
+		if (!this.#config.importedPackages.includes(path)) {
+			this.#config.importedPackages = [...this.#config.importedPackages, path];
+			if (this.#persist) await saveConfig(this.#config);
+		}
+		await this.#refreshPackages();
+	}
+	/** 页面加载完成后的主动重推（对齐 hello）。 */
+	ping() {
+		this.#emit();
+	}
+	view(id) {
+		const rt = this.#rts.get(id);
+		return rt ? this.#view(rt) : null;
+	}
+	async start(id) {
+		const rt = this.#rts.get(id);
+		if (!rt) return;
+		if (rt.processState === "running" || rt.processState === "starting") return;
+		if (!rt.meta?.configured) {
+			rt.lastError = "实例尚未注册（目录缺 .runner），先走注册表单";
+			this.#emit();
+			return;
+		}
+		rt.lastError = null;
+		let spawnError = null;
+		const spawned = startRunner(rt.dir, (stream, line) => this.#onManagedLine(rt, stream, line), (err) => {
+			spawnError = err;
+		});
+		if (!spawned) {
+			rt.lastError = "无法启动 runner（检查 run.sh / Runner.Listener.exe 是否存在且有执行权限）";
+			this.#emit();
+			return;
+		}
+		rt.child = spawned;
+		rt.pid = spawned.pid;
+		rt.external = false;
+		rt.processState = "starting";
+		spawned.child.on("close", (code, signal) => {
+			if (rt.child?.pid !== spawned.pid) return;
+			rt.child = null;
+			rt.pid = null;
+			rt.processState = "stopped";
+			rt.currentJob = null;
+			rt.lastError = spawnError ? `启动失败：${spawnError.message}` : signal === "SIGTERM" || code === 0 ? null : `进程退出 code=${code} signal=${signal ?? "none"}（详见日志）`;
+			this.#emitSoon();
+		});
+		this.#emitSoon();
+	}
+	async stop(id) {
+		const rt = this.#rts.get(id);
+		if (!rt) return;
+		if (rt.processState !== "running" && rt.processState !== "starting") return;
+		if (rt.pid == null) return;
+		rt.processState = "stopping";
+		rt.stoppingUntilMs = Date.now() + 15e3;
+		this.#emit();
+		const pid = rt.pid;
+		const wasExternal = rt.external;
+		if (wasExternal) {
+			const identity = await pidIdentity(pid);
+			const rtDirReal = await realpath(rt.dir).catch(() => rt.dir);
+			const same = (a, b) => {
+				if (a === null) return false;
+				if (PLATFORM === "win32") return a.replace(/\\/g, "/").toLowerCase() === b.replace(/\\/g, "/").toLowerCase();
+				return a === b || a === rtDirReal;
+			};
+			if (identity === null) {
+				if (pidExists(pid) !== "dead") {} else {
+					rt.pid = null;
+					rt.external = false;
+					rt.processState = "stopped";
+					rt.currentJob = null;
+					this.#emit();
+					return;
+				}
+			} else if (!same(identity, rt.dir)) {
+				rt.lastError = "停止已取消：该 pid 已不属于本实例（等待重新对账）";
+				rt.pid = null;
+				rt.external = false;
+				rt.processState = "stopped";
+				this.#emit();
+				return;
+			}
+		}
+		const ok = await stopProcessGroup(pid, wasExternal ? 6e3 : 8e3);
+		if (wasExternal) {
+			rt.external = false;
+			rt.pid = null;
+			rt.processState = ok ? "stopped" : "running";
+			if (!ok) rt.lastError = "停止失败：进程无响应或无权限（可能由 sudo 启动）";
+			rt.currentJob = null;
+		}
+		this.#emit();
+	}
+	async setAutoStart(id, value) {
+		const rt = this.#rts.get(id);
+		if (!rt || !this.#config) return;
+		rt.autoStart = value;
+		this.#config = upsertInstance(this.#config, {
+			id: rt.id,
+			dir: rt.dir,
+			autoStart: value
+		});
+		await saveConfig(this.#config);
+		this.#emitSoon();
+	}
+	async register(req) {
+		if (this.#task.kind === "register" && this.#task.status === "running") return;
+		this.#task = {
+			kind: "register",
+			status: "running",
+			message: null
+		};
+		this.#emit();
+		const existing = this.#rts.get(instanceIdOf(req.dir));
+		const result = await registerRunner(req, this.#config?.searchDirs ?? [], (line) => {
+			this.#task = {
+				kind: "register",
+				status: "running",
+				message: line
+			};
+			if (existing) this.#pushLog(existing, line);
+			this.#emitSoon();
+		});
+		if (result.ok) {
+			const id = instanceIdOf(result.runnerDir);
+			const rt = this.#ensureRt(result.runnerDir, true);
+			rt.meta = await readRunnerMeta(result.runnerDir);
+			if (this.#config) {
+				this.#config = upsertInstance(this.#config, {
+					id,
+					dir: result.runnerDir,
+					autoStart: false
+				});
+				await saveConfig(this.#config);
+			}
+			this.#task = {
+				kind: "register",
+				status: "ok",
+				message: `${rt.meta.agentName ?? id} 注册成功`
+			};
+			await this.start(id);
+		} else this.#task = {
+			kind: "register",
+			status: "error",
+			message: result.error
+		};
+		this.#emit();
+	}
+	async destroy() {
+		if (this.#tickTimer) clearInterval(this.#tickTimer);
+		this.#tickTimer = null;
+		for (const rt of this.#rts.values()) rt.tail?.stop();
+	}
+	#ensureRt(dir, create) {
+		const id = instanceIdOf(dir);
+		let rt = this.#rts.get(id);
+		if (!rt && create) {
+			rt = {
+				id,
+				dir,
+				meta: null,
+				processState: "stopped",
+				external: false,
+				autoStart: false,
+				pid: null,
+				child: null,
+				currentJob: null,
+				lastResult: null,
+				lastError: null,
+				log: [],
+				logTotal: 0,
+				seen: /* @__PURE__ */ new Set(),
+				tail: null,
+				stoppingUntilMs: 0
+			};
+			this.#rts.set(id, rt);
+		}
+		return rt;
+	}
+	async #syncInstances() {
+		const config = this.#config;
+		if (!config) return;
+		const discovered = await discoverRunnerDirs(config.searchDirs);
+		const dirs = /* @__PURE__ */ new Set([...discovered, ...config.instances.map((i) => i.dir)]);
+		let changed = false;
+		for (const dir of dirs) try {
+			const rt = this.#ensureRt(dir, true);
+			rt.meta = await readRunnerMeta(dir);
+			const cfgAuto = config.instances.find((i) => i.dir === dir || i.id === rt.id);
+			rt.autoStart = cfgAuto?.autoStart ?? false;
+			if (!cfgAuto && this.#persist) {
+				config.instances = upsertInstance(config, {
+					id: rt.id,
+					dir,
+					autoStart: false
+				}).instances;
+				changed = true;
+			}
+			if (!rt.tail) {
+				rt.tail = new DirTail(join(dir, "_diag"), "Runner_");
+				rt.tail.start((lines) => this.#onDiagLines(rt, lines));
+			}
+		} catch {}
+		if (changed && this.#persist) await saveConfig(config);
+	}
+	#onDiagLines(rt, lines) {
+		for (const line of lines) {
+			const event = parseConsoleLine(line);
+			if (event) this.#applyJobEvent(rt, event);
+			this.#pushLog(rt, normalizeLine(line) ?? stripDiagPrefix(line));
+		}
+		this.#emitSoon();
+	}
+	#onManagedLine(rt, stream, line) {
+		if (!parseConsoleLine(line)) {
+			this.#pushLog(rt, (stream === "stderr" ? "[stderr] " : "") + line);
+			this.#emitSoon();
+		}
+		if (rt.processState === "starting") {
+			rt.processState = "running";
+			this.#emitSoon();
+		}
+	}
+	#applyJobEvent(rt, event) {
+		if (!event) return;
+		if (event.kind === "job-start") rt.currentJob = {
+			job: event.job,
+			startedAt: event.at
+		};
+		else if (event.kind === "job-end") {
+			const startedAtMs = rt.currentJob ? Date.parse(rt.currentJob.startedAt) : NaN;
+			rt.lastResult = {
+				job: event.job,
+				outcome: event.outcome,
+				at: event.at,
+				durationMs: Number.isFinite(startedAtMs) ? Math.max(0, Date.parse(event.at) - startedAtMs) : 0
+			};
+			rt.currentJob = null;
+		} else rt.currentJob = null;
+	}
+	#pushLog(rt, line) {
+		if (rt.seen.has(line)) return;
+		rt.seen.add(line);
+		if (rt.seen.size > DEDUP_MAX) rt.seen = new Set([...rt.seen].slice(-1200));
+		rt.log.push(line);
+		rt.logTotal += 1;
+		if (rt.log.length > LOG_RING_MAX) rt.log.splice(0, rt.log.length - LOG_RING_MAX);
+	}
+	async #tick() {
+		try {
+			await this.#syncInstances();
+			await this.#reconcileExternal();
+			await this.#refreshPackages();
+		} catch {}
+	}
+	async #reconcileExternal() {
+		const cwdByPid = await findListenerProcesses();
+		const dirsRunning = new Set(cwdByPid.values());
+		for (const rt of this.#rts.values()) {
+			if (rt.stoppingUntilMs > Date.now()) continue;
+			if (rt.child) continue;
+			const rtDir = await realpath(rt.dir).catch(() => rt.dir);
+			const externalPid = [...cwdByPid.entries()].find(([, cwd]) => cwd === rtDir)?.[0] ?? null;
+			const isRunning = dirsRunning.has(rtDir);
+			if (externalPid !== null) {
+				if (rt.processState !== "running" || rt.external !== true) {
+					rt.processState = "running";
+					rt.external = true;
+					rt.pid = externalPid;
+					rt.lastError = null;
+					this.#emitSoon();
+				}
+			} else if (rt.external && rt.processState === "running" && !isRunning) {
+				rt.processState = "stopped";
+				rt.external = false;
+				rt.pid = null;
+				rt.currentJob = null;
+				this.#emitSoon();
+			}
+		}
+	}
+	#view(rt) {
+		return {
+			id: rt.id,
+			dir: rt.dir,
+			name: rt.meta?.agentName ?? rt.id,
+			agentId: rt.meta?.agentId ?? null,
+			orgUrl: rt.meta?.gitHubUrl ?? null,
+			workFolder: rt.meta?.workFolder ?? null,
+			configured: rt.meta?.configured ?? false,
+			processState: rt.processState,
+			external: rt.external,
+			autoStart: rt.autoStart,
+			pid: rt.pid,
+			currentJob: rt.currentJob,
+			lastResult: rt.lastResult,
+			lastError: rt.lastError,
+			log: rt.log,
+			logTotal: rt.logTotal
+		};
+	}
+	#emit() {
+		const snap = this.snapshot();
+		for (const listener of this.#listeners) listener(snap);
+	}
+	#emitSoon() {
+		this.#dirty = true;
+		if (this.#debounceTimer) return;
+		this.#debounceTimer = setTimeout(() => {
+			this.#debounceTimer = null;
+			if (!this.#dirty) return;
+			this.#dirty = false;
+			this.#emit();
+		}, DEBOUNCE_MS);
+		this.#debounceTimer.unref?.();
+	}
+};
+// src/tray.ts
+const ITEM_OPEN = 1;
+const ITEM_QUIT = 2;
+const ITEM_INSTANCE_BASE = 100;
+function stateLabel(snapshot, index) {
+	const i = snapshot.instances[index];
+	if (i.currentJob) return `↻ ${i.currentJob.job}`;
+	switch (i.processState) {
+		case "running": return "空闲";
+		case "stopped": return "已停止";
+		case "starting": return "启动中…";
+		case "stopping": return "停止中…";
+		default: return i.processState;
+	}
+}
+/** 快照 → 托盘投影器。每次 update() 全量重画图标/tooltip/菜单。 */
+var TrayProjection = class {
+	tray;
+	actions;
+	#instanceIds = [];
+	constructor(tray, actions) {
+		this.tray = tray;
+		this.actions = actions;
+	}
+	async update(snapshot) {
+		this.#instanceIds = snapshot.instances.map((i) => i.id);
+		const running = snapshot.instances.filter((i) => i.processState === "running" || i.processState === "starting");
+		const busy = running.filter((i) => i.currentJob !== null).length;
+		await this.tray.setIcon({ "text-only": busy > 0 ? `▶${running.length}↻${busy}` : `▶${running.length}` });
+		await this.tray.setTooltip({
+			title: "GH Runner",
+			description: snapshot.instances.map((_, index) => `${snapshot.instances[index].name}: ${stateLabel(snapshot, index)}`).join("\n") || "尚无实例"
+		});
+		await this.tray.setMenu(this.#menuOf(snapshot));
+	}
+	/** onMenuClick 事件入口；返回是否已消费。 */
+	handleMenuClick(itemId) {
+		if (itemId === ITEM_OPEN) {
+			this.actions.openWindow();
+			return true;
+		}
+		if (itemId === ITEM_QUIT) {
+			this.actions.quit();
+			return true;
+		}
+		const index = itemId - ITEM_INSTANCE_BASE;
+		const id = this.#instanceIds[index];
+		if (id) {
+			this.actions.openInstance(id);
+			return true;
+		}
+		return false;
+	}
+	#menuOf(snapshot) {
+		const items = [{
+			type: "item",
+			id: ITEM_OPEN,
+			title: "打开控制面板",
+			primaryEvent: true
+		}];
+		if (snapshot.instances.length > 0) items.push({ type: "separator" });
+		snapshot.instances.forEach((instance, index) => {
+			items.push({
+				type: "item",
+				id: ITEM_INSTANCE_BASE + index,
+				title: `${instance.name} — ${stateLabel(snapshot, index)}`
+			});
+		});
+		items.push({ type: "separator" });
+		items.push({
+			type: "item",
+			id: ITEM_QUIT,
+			title: "退出 GH Runner"
+		});
+		return { items };
+	}
+};
+// src/window.ts
+const DRAIN_INTERVAL_MS = 150;
+const PUSH_DEBOUNCE_MS = 120;
+/** U+2028/2029 会切断 JS 对象字面量，序列化后必须转义（不可见字符法则）。 */
+function jsLiteral(value) {
+	return value.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+}
+var UiHost = class {
+	fleet;
+	webviewTray;
+	onOpenDiag;
+	pickPackageFile;
+	#window = null;
+	#lastSnapshot = null;
+	#ackedSeq = 0;
+	#drainTimer = null;
+	#pushTimer = null;
+	/** 每实例已推送的日志绝对计数（logTotal），0=从头全量。 */
+	#logOffsets = /* @__PURE__ */ new Map();
+	#seq = 0;
+	/** 单飞守卫：hello 全量重推与去抖推送并发交错会让同一批日志行重复送达页面。 */
+	#pushInFlight = false;
+	#pushPending = false;
+	constructor(fleet, webviewTray, onOpenDiag, pickPackageFile) {
+		this.fleet = fleet;
+		this.webviewTray = webviewTray;
+		this.onOpenDiag = onOpenDiag;
+		this.pickPackageFile = pickPackageFile;
+	}
+	async open() {
+		if (this.#window) {
+			await this.#window.show();
+			await this.#window.focus();
+			return;
+		}
+		const htmlPath = join(dirname(fileURLToPath(import.meta.url)), "ui", "index.html");
+		const html = await readFile(htmlPath, "utf8");
+		const win = this.webviewTray.createWebviewWindow({
+			html,
+			width: 1020,
+			height: 700,
+			title: "GH Runner",
+			nativeWindowApi: true,
+			devtools: true,
+			style: {
+				appMode: true,
+				autoHide: false,
+				frameless: false
+			}
+		});
+		this.#window = win;
+		await win.show();
+		await win.setMinimumSize(720, 520);
+		this.#drainTimer = setInterval(() => void this.#drain(), DRAIN_INTERVAL_MS);
+		this.#drainTimer.unref?.();
+		this.#flush();
+	}
+	push(snapshot) {
+		this.#lastSnapshot = snapshot;
+		this.#flush();
+	}
+	/** --smoke 自走查用：页面最近一次 ack 的消息 seq（>0 即真实链路 host→page→host 闭环）。 */
+	get ackedSeq() {
+		return this.#ackedSeq;
+	}
+	/** --smoke 自走查用：最近一次收到的快照。 */
+	get lastSnapshot() {
+		return this.#lastSnapshot;
+	}
+	/** --smoke 对照实验：绕过快照管道，直接 evaluate 一个最小 summary。 */
+	async debugPushMinimal() {
+		const win = this.#window;
+		if (!win) return;
+		try {
+			await win.evaluate(`window.__rfSink({kind:"summary",seq:99999,now:new Date().toISOString(),task:{kind:"none",status:"ok",message:null},instances:[]})`);
+		} catch (err) {
+			if (process.env.RF_DEBUG) console.error("[ui] minimal evaluate 失败:", err);
+		}
+	}
+	async destroy() {
+		if (this.#drainTimer) clearInterval(this.#drainTimer);
+		if (this.#pushTimer) clearTimeout(this.#pushTimer);
+		this.#drainTimer = null;
+		this.#pushTimer = null;
+	}
+	#flush() {
+		if (this.#pushTimer || !this.#window) return;
+		this.#pushTimer = setTimeout(() => {
+			this.#pushTimer = null;
+			this.#doPush();
+		}, PUSH_DEBOUNCE_MS);
+		this.#pushTimer.unref?.();
+	}
+	async #doPush() {
+		const win = this.#window;
+		const snap = this.#lastSnapshot;
+		if (!win || !snap || win.connectionDead) return;
+		if (this.#pushInFlight) {
+			this.#pushPending = true;
+			return;
+		}
+		this.#pushInFlight = true;
+		try {
+			const summary = {
+				kind: "summary",
+				seq: ++this.#seq,
+				now: snap.now,
+				platform: snap.platform,
+				arch: snap.arch,
+				task: snap.task,
+				instances: snap.instances.map((inst) => {
+					const { log: _log, ...rest } = inst;
+					return rest;
+				}),
+				packages: snap.packages,
+				download: snap.download
+			};
+			await this.#evaluate(JSON.stringify(summary));
+			for (const inst of snap.instances) await this.#pushLogDelta(win, inst.id);
+		} finally {
+			this.#pushInFlight = false;
+			if (this.#pushPending && this.#window) {
+				this.#pushPending = false;
+				this.#flush();
+			}
+		}
+	}
+	async #pushLogDelta(win, id) {
+		const view = this.fleet.view(id);
+		if (!view) return;
+		const pushed = this.#logOffsets.get(id) ?? 0;
+		const total = view.logTotal;
+		if (total === pushed) return;
+		const wanted = total - pushed;
+		const available = Math.min(wanted, view.log.length);
+		const allLines = view.log.slice(view.log.length - available);
+		const truncated = available < wanted;
+		const chunks = [];
+		let cur = [];
+		let bytes = 0;
+		for (const line of allLines) {
+			const b = Buffer.byteLength(line, "utf8") + 1;
+			if (bytes + b > 24e3 && cur.length > 0) {
+				chunks.push(cur);
+				cur = [];
+				bytes = 0;
+			}
+			cur.push(line);
+			bytes += b;
+		}
+		if (cur.length > 0) chunks.push(cur);
+		let offset = total - allLines.length;
+		for (const lines of chunks) {
+			const msg = {
+				kind: "log",
+				seq: ++this.#seq,
+				id,
+				from: truncated && offset === total - allLines.length ? 0 : offset,
+				truncated: truncated && offset === total - allLines.length,
+				lines
+			};
+			if (!await this.#evaluate(JSON.stringify(msg))) return;
+			offset += lines.length;
+			this.#logOffsets.set(id, offset);
+		}
+	}
+	async #evaluate(json) {
+		const win = this.#window;
+		if (!win || win.connectionDead) return false;
+		try {
+			const js = `window.__rfSink(${jsLiteral(json)})`;
+			if (process.env.RF_DEBUG) console.error(`[ui] evaluate ${js.length} bytes: ${json.slice(0, 60)}`);
+			await win.evaluate(js);
+			return true;
+		} catch (err) {
+			if (process.env.RF_DEBUG) console.error("[ui] evaluate 失败:", err);
+			return false;
+		}
+	}
+	async #drain() {
+		const win = this.#window;
+		if (!win || win.connectionDead) return;
+		let messages;
+		try {
+			messages = await win.drainIpcMessages();
+		} catch (err) {
+			if (process.env.RF_DEBUG) console.error("[ui] drain 失败:", err);
+			return;
+		}
+		for (const message of messages) {
+			if (process.env.RF_DEBUG) console.error("[ui] ipc <-", JSON.stringify(message.payload).slice(0, 120));
+			const cmd = message.payload;
+			if (!cmd || typeof cmd !== "object") continue;
+			await this.#handle(cmd);
+		}
+	}
+	async #handle(cmd) {
+		switch (cmd.type) {
+			case "hello":
+				this.#logOffsets.clear();
+				this.#flush();
+				break;
+			case "ack":
+				if (cmd.seq > this.#ackedSeq) this.#ackedSeq = cmd.seq;
+				break;
+			case "start":
+				await this.fleet.start(cmd.id);
+				break;
+			case "stop":
+				await this.fleet.stop(cmd.id);
+				break;
+			case "set-auto-start":
+				await this.fleet.setAutoStart(cmd.id, cmd.value);
+				break;
+			case "open-diag":
+				this.onOpenDiag(cmd.id);
+				break;
+			case "register":
+				await this.fleet.register({
+					dir: cmd.dir,
+					name: cmd.name,
+					token: cmd.token,
+					labels: cmd.labels,
+					orgUrl: cmd.orgUrl,
+					workFolder: cmd.workFolder,
+					packagePath: cmd.packagePath
+				});
+				break;
+			case "download-latest":
+				this.fleet.downloadLatest();
+				break;
+			case "import-package": {
+				const picked = await this.pickPackageFile();
+				if (picked) await this.fleet.importPackage(picked);
+				break;
+			}
+		}
+	}
+};
+/** 从托盘句柄构造 Webview 能力的便利封装（保持 main.ts 干净）。 */
+function extendWebview(tray) {
+	return tray.extend(WebviewExt);
+}
+// src/main.ts
+const APP_ID = "com.jixoai.gh-runner";
+async function revealPath(path) {
+	const { file, args } = revealInFileManager(path);
+	await new Promise((resolve) => {
+		execFile(file, args, () => resolve());
+	});
+}
+/** 导入本地分发包：系统文件选择框（ext-dialog；darwin NSOpenPanel / win32 对话框）。 */
+async function pickPackageFile(tray) {
+	try {
+		const picked = await attachDialog(tray).pickFile({ filters: [{
+			name: "runner 包",
+			extensions: ["gz", "zip"]
+		}] });
+		return typeof picked === "string" ? picked : null;
+	} catch (err) {
+		console.error("[gh-runner] 包选择失败:", err);
+		return null;
+	}
+}
+/** --probe：探明真实窗口里注入的页面桥形态。三通道取证：页面 ipc 上行 / 宿主 evaluate 内省 +
+*  titlechange 回传 / loadstate 时机观测。 */
+async function runProbe() {
+	const tray = await createTray({
+		id: APP_ID,
+		icon: { "text-only": "probe" }
+	}, {
+		appId: APP_ID,
+		appName: "GH Runner Probe"
+	});
+	const win = extendWebview(tray).createWebviewWindow({
+		html: `<script>
+      window.__probeState = { started: true };
+      try {
+        navigator.opentray.ipc.postMessage({ t: "probe-ipc", ok: true,
+          opentray: Object.keys(navigator.opentray) });
+      } catch (e) { window.__probeState.ipcError = String(e); }
+    <\/script>`,
+		width: 500,
+		height: 200,
+		nativeWindowApi: true,
+		titleSync: { documentToWindow: true }
+	});
+	const report = {
+		ipc: "none",
+		loadstate: [],
+		titlechange: "none"
+	};
+	const finish = async () => {
+		await writeFile("/tmp/gh-runner-probe.json", JSON.stringify(report, null, 2), "utf8");
+		await win.destroy();
+		await tray.destroy();
+		process.exit(0);
+	};
+	win.listen("loadstate", (event) => {
+		const phase = event.payload?.phase ?? "unknown";
+		report.loadstate = [...report.loadstate, phase];
+		if (phase === "loaded") win.evaluate(`document.title = "PROBE:" + JSON.stringify({
+            opentray: (typeof navigator.opentray !== "undefined") ? Object.keys(navigator.opentray) : null,
+            ipc: !!navigator.opentray?.ipc,
+            opentrayWindow: (typeof navigator.opentrayWindow !== "undefined") ? Object.keys(navigator.opentrayWindow) : null
+          })`).catch((err) => {
+			report.evaluateError = String(err);
+		});
+	});
+	win.listen("titlechange", (event) => {
+		if (event.payload.title.startsWith("PROBE:")) {
+			report.titlechange = event.payload.title.slice(6);
+			finish();
+		}
+	});
+	await win.show();
+	setInterval(() => {
+		win.drainIpcMessages().then((msgs) => {
+			for (const m of msgs) if (m.payload?.t === "probe-ipc") {
+				report.ipc = m.payload;
+				finish();
+			}
+		}).catch(() => {});
+	}, 200).unref?.();
+	const deadline = Date.now() + 2e4;
+	while (Date.now() < deadline) await new Promise((r) => setTimeout(r, 300));
+	await finish();
+}
+async function runSmoke(fleet, uiHost) {
+	await uiHost.open();
+	const deadline = Date.now() + 3e4;
+	while (Date.now() < deadline && uiHost.ackedSeq === 0) await new Promise((r) => setTimeout(r, 250));
+	if (uiHost.ackedSeq === 0) {
+		console.error("[smoke] 全量快照未获 ack，尝试最小快照对照");
+		await uiHost.debugPushMinimal();
+		const t = Date.now();
+		while (Date.now() - t < 5e3 && uiHost.ackedSeq === 0) await new Promise((r) => setTimeout(r, 250));
+		console.error(`[smoke] 最小快照 ackedSeq=${uiHost.ackedSeq}`);
+	}
+	const snap = uiHost.lastSnapshot;
+	await writeFile("/tmp/gh-runner-smoke.json", JSON.stringify({
+		ok: uiHost.ackedSeq > 0,
+		ackedSeq: uiHost.ackedSeq,
+		pushedSeq: snap?.seq ?? 0,
+		instances: snap?.instances.map((i) => ({
+			id: i.id,
+			name: i.name,
+			processState: i.processState,
+			external: i.external,
+			currentJob: i.currentJob,
+			lastResult: i.lastResult,
+			logLines: i.log.length
+		})) ?? []
+	}, null, 2), "utf8");
+	const holdMs = Number(process.env.RF_SMOKE_HOLD ?? "0");
+	if (holdMs > 0) await new Promise((r) => setTimeout(r, holdMs));
+	await fleet.destroy();
+	process.exit(0);
+}
+async function main() {
+	const mode = process.argv[2] ?? "";
+	if (mode === "--probe") {
+		await runProbe();
+		return;
+	}
+	const fleet = new Fleet();
+	await fleet.boot(mode === "--dry-run" || mode === "--smoke" ? {
+		autoStart: false,
+		persist: false
+	} : {});
+	if (mode === "--dry-run") {
+		const iterations = Number(process.argv[3] ?? "3");
+		await new Promise((r) => setTimeout(r, 3e3));
+		for (let i = 0; i < iterations; i++) {
+			const snap = fleet.snapshot();
+			console.log(JSON.stringify(snap.instances.map((inst) => ({
+				id: inst.id,
+				name: inst.name,
+				state: inst.processState,
+				external: inst.external,
+				job: inst.currentJob?.job ?? null,
+				last: inst.lastResult ? `${inst.lastResult.job}=${inst.lastResult.outcome}` : null,
+				logLines: inst.log.length
+			}))));
+			if (i < iterations - 1) await new Promise((r) => setTimeout(r, 3e3));
+		}
+		await fleet.destroy();
+		return;
+	}
+	const tray = await createTray({
+		id: APP_ID,
+		icon: { "text-only": "▶…" },
+		menu: { items: [{
+			type: "item",
+			id: 1,
+			title: "打开控制面板",
+			primaryEvent: true
+		}] }
+	}, {
+		appId: APP_ID,
+		appName: "GH Runner"
+	});
+	const projection = new TrayProjection(tray, {
+		openWindow: () => void uiHost.open(),
+		openInstance: (id) => {
+			uiHost.open();
+			Promise.resolve(id);
+		},
+		quit: () => void shutdown()
+	});
+	const uiHost = new UiHost(fleet, extendWebview(tray), (id) => {
+		const view = fleet.view(id);
+		if (view) revealPath(`${view.dir}/_diag`);
+	}, () => pickPackageFile(tray));
+	fleet.onSnapshot((snap) => {
+		projection.update(snap);
+		uiHost.push(snap);
+	});
+	tray.onMenuClick(({ itemId }) => {
+		if (!projection.handleMenuClick(itemId)) console.warn(`[tray] 未路由的菜单项 ${itemId}`);
+	});
+	if (mode === "--smoke") {
+		runSmoke(fleet, uiHost);
+		return;
+	}
+	const shutdown = async () => {
+		await uiHost.destroy();
+		await tray.destroy();
+		await fleet.destroy();
+		process.exit(0);
+	};
+	process.on("SIGINT", () => void shutdown());
+	process.on("SIGTERM", () => void shutdown());
+	console.log(`[gh-runner] 已启动（配置目录 ${homedir()}/Library/Application Support/gh-runner）`);
+}
+main().catch((err) => {
+	console.error("[gh-runner] 启动失败:", err);
+	process.exit(1);
+});
+export {};