@ellieyujin/pi-reopen 0.0.0-stage → 0.2.0-dev.0

package/src/paths.js

@@ -0,0 +1,21 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** Pi agent 目录，尊重 PI_CODING_AGENT_DIR（与 pi 本体一致）。 */
+export function agentDir(env = process.env) {
+	return env.PI_CODING_AGENT_DIR || join(env.HOME || homedir(), ".pi", "agent");
+}
+
+/** pi-workspace 全部持久化路径。 */
+export function workspacePaths(env = process.env) {
+	const agent = agentDir(env);
+	return {
+		agent,
+		workspace: join(agent, "pi-workspace"),
+		members: join(agent, "pi-workspace", "members"),
+		claims: join(agent, "pi-workspace", "starting"),
+		sessions: join(agent, "sessions"),
+		legacyRegistry: join(agent, "pi-terminals.json"),
+		legacyRecords: join(agent, "pi-terminal-records"),
+	};
+}

package/src/plan.js

@@ -0,0 +1,79 @@
+import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { isLive } from "./liveness.js";
+import { workspacePaths } from "./paths.js";
+
+/** 由记录定位会话文件：优先记录内绝对路径，否则按 sessionId 扫描会话目录。 */
+export function resolveSessionFile(entry, paths = workspacePaths()) {
+	if (entry.sessionFile && existsSync(entry.sessionFile)) return entry.sessionFile;
+	try {
+		for (const dir of readdirSync(paths.sessions)) {
+			const p = join(paths.sessions, dir);
+			if (!statSync(p).isDirectory()) continue;
+			const file = readdirSync(p).find((f) => f.endsWith(`_${entry.sessionId}.jsonl`));
+			if (file) return join(p, file);
+		}
+	} catch {
+		/* 无会话目录 */
+	}
+	return undefined;
+}
+
+function dedupeKey(sessionFile) {
+	try {
+		return realpathSync(sessionFile);
+	} catch {
+		return sessionFile;
+	}
+}
+
+/**
+ * 生成恢复计划。状态语义：
+ * live        进程仍存活，跳过（也自然排除了发起恢复的当前会话）
+ * claimed     其他恢复进程正在启动它，跳过
+ * missing-cwd 工作目录不存在，跳过并报告
+ * missing-file 会话文件不存在（未落盘/已删除），跳过并报告
+ * duplicate   与更早条目指向同一会话文件（含别名），跳过
+ * restorable  待恢复
+ */
+export function buildRestorePlan({
+	members,
+	paths = workspacePaths(),
+	liveFn = isLive,
+	claimFn,
+	bootId,
+}) {
+	const seen = new Set();
+	const items = [];
+	const sorted = [...members].sort((a, b) => a.ts - b.ts);
+	for (const entry of sorted) {
+		let state = "restorable";
+		let sessionFile;
+		let detail;
+		if (liveFn(entry, { bootId })) {
+			state = "live";
+		} else if (claimFn?.(entry.sessionId)) {
+			state = "claimed";
+		} else if (!existsSync(entry.cwd)) {
+			state = "missing-cwd";
+		} else {
+			sessionFile = resolveSessionFile(entry, paths);
+			if (!sessionFile) {
+				state = "missing-file";
+			} else {
+				const key = dedupeKey(sessionFile);
+				if (seen.has(key)) {
+					state = "duplicate";
+				} else {
+					seen.add(key);
+				}
+			}
+		}
+		items.push({ entry, sessionFile, state });
+	}
+	return {
+		items,
+		restorable: items.filter((i) => i.state === "restorable"),
+		count: (state) => items.filter((i) => i.state === state).length,
+	};
+}

package/src/preflight.js

@@ -0,0 +1,91 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { discoverWezterm } from "./discover.js";
+import { launchSetup, shellQuote } from "./launch.js";
+
+const BINFMT_FIX_HINT =
+	"WSLInterop 未注册，Windows 程序无法从 WSL 启动。" +
+	"请在普通 Shell 执行（需 sudo 密码，工具不会自动执行）：\n" +
+	"printf '%s\\n' ':WSLInterop:M::MZ::/init:P' | sudo tee /proc/sys/fs/binfmt_misc/register >/dev/null";
+
+function isFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+
+/** 启动前环境检查；任何一项不通过都不得批量开标签页。 */
+export function preflight({ env = process.env, wezterm, prober, piProber } = {}) {
+	const checks = [];
+	const add = (name, ok, detail, hint) => checks.push({ name, ok, detail, hint });
+
+	const distro = env.WSL_DISTRO_NAME;
+	add("WSL 发行版", !!distro, distro || "未设置", distro ? undefined : "恢复仅支持 WSL + Windows WezTerm；缺少 WSL_DISTRO_NAME，无法定向启动标签页");
+
+	add("WSL 互操作套接字", existsSync("/run/WSL"), "/run/WSL", existsSync("/run/WSL") ? undefined : "未找到 /run/WSL，WSL 互操作未启用（检查 wsl.conf 的 interop 设置）");
+
+	const explicit = wezterm ?? env.PI_WORKSPACE_WEZTERM;
+	let found;
+	if (explicit) {
+		if (isFile(explicit)) {
+			found = explicit;
+			add("WezTerm 程序", true, found);
+		} else {
+			add(
+				"WezTerm 程序",
+				false,
+				`指定的文件不存在：${explicit}`,
+				"检查 PI_WORKSPACE_WEZTERM 环境变量或传入的路径",
+			);
+		}
+	} else {
+		found = discoverWezterm(env);
+		add(
+			"WezTerm 程序",
+			!!found,
+			found || "未找到",
+			found ? undefined : "未找到 wezterm.exe；可用环境变量 PI_WORKSPACE_WEZTERM 指定完整路径",
+		);
+	}
+
+	if (found) {
+		const probe = prober
+			? prober(found)
+			: spawnSync(found, ["--version"], { timeout: 8000, encoding: "utf8" });
+		if (probe.status === 0) {
+			add("Windows 程序执行", true, String(probe.stdout ?? "").trim() || "ok");
+		} else {
+			const enoexec = probe.error?.code === "ENOEXEC";
+			add(
+				"Windows 程序执行",
+				false,
+				enoexec ? "Exec format error (ENOEXEC)" : String(probe.stderr ?? probe.error ?? "").trim(),
+				enoexec ? BINFMT_FIX_HINT : "wezterm.exe 无法执行；确认安装完整且为 Windows 版本",
+			);
+		}
+	}
+
+	const explicitPi = env.PI_WORKSPACE_PI_BIN;
+	const candidate = explicitPi ? shellQuote(explicitPi) : '"$pi_bin"';
+	const probeScript = [
+		launchSetup(env, explicitPi),
+		...(explicitPi ? [] : ['pi_bin=$(type -P pi) || exit 1']),
+		`[[ ${candidate} = /* && -f ${candidate} && -x ${candidate} ]] || exit 1`,
+		`printf '%s\\n' ${candidate}`,
+	].join("; ");
+	const piProbe = piProber
+		? piProber()
+		: spawnSync("bash", ["-lc", probeScript], { env, timeout: 5000, encoding: "utf8" });
+	const piPath = String(piProbe.stdout ?? "").trim().split(/\r?\n/).at(-1);
+	const piOk = piProbe.status === 0 && !!piPath;
+	add(
+		"pi 命令",
+		piOk,
+		piOk ? piPath : explicitPi || "未找到",
+		piOk ? undefined : "请先安装 pi 并加入 PATH，或设置 PI_WORKSPACE_PI_BIN 为 WSL 内可执行文件的绝对路径（不含参数、别名或 Shell 函数）",
+	);
+
+	return { ok: checks.every((c) => c.ok), wezterm: found, checks, distro, piBin: piOk ? piPath : undefined };
+}

package/src/restore.js

@@ -0,0 +1,132 @@
+import { claimSession, sweepClaims } from "./claims.js";
+import { listMembers } from "./members.js";
+import { buildRestorePlan } from "./plan.js";
+import { preflight } from "./preflight.js";
+import { openTab } from "./spawn.js";
+import { workspacePaths } from "./paths.js";
+import { currentBootId } from "./liveness.js";
+import { waitForMembers } from "./verify.js";
+
+const STATE_LABEL = {
+	live: "运行中",
+	claimed: "启动占用中",
+	"missing-cwd": "工作目录缺失",
+	"missing-file": "会话文件缺失",
+	duplicate: "重复条目",
+	restorable: "待恢复",
+};
+
+export function label(state) {
+	return STATE_LABEL[state] ?? state;
+}
+
+/** 只读：列出全部成员与状态（list / dry-run 共用）。 */
+export function inspect({ paths = workspacePaths() } = {}) {
+	const members = listMembers(paths);
+	const plan = buildRestorePlan({
+		members,
+		paths,
+		claimFn: () => false,
+		bootId: currentBootId(),
+	});
+	return { members, plan };
+}
+
+/**
+ * 恢复编排：预检 → 计划 → 声明启动占用 → 逐个开标签页 → 等待登记确认。
+ * 结果如实区分：requested（WezTerm 接受请求）与 verified（Pi 已启动并登记）。
+ */
+export async function runRestore({
+	env = process.env,
+	paths = workspacePaths(env),
+	dryRun = false,
+	noWait = false,
+	waitTimeoutMs = 15_000,
+	spawner,
+	prober,
+	piProber,
+} = {}) {
+	const pre = preflight({ env, prober, piProber });
+	if (!pre.ok) {
+		return { ok: false, stage: "preflight", checks: pre.checks };
+	}
+	sweepClaims(paths);
+	const { plan } = inspect({ paths });
+	if (dryRun) {
+		return { ok: true, stage: "dry-run", plan };
+	}
+	const baseline = Date.now();
+	const results = [];
+	for (const item of plan.restorable) {
+		const claim = claimSession(item.entry.sessionId, process.pid, paths);
+		if (!claim.claimed) {
+			results.push({ ...item, state: "claimed" });
+			continue;
+		}
+		const spawnResult = await openTab({
+			wezterm: pre.wezterm,
+			distro: pre.distro,
+			piBin: pre.piBin,
+			env,
+			cwd: item.entry.cwd,
+			sessionFile: item.sessionFile,
+			spawner,
+		});
+		results.push({
+			...item,
+			requested: spawnResult.ok,
+			requestError: spawnResult.ok ? undefined : spawnResult.error,
+		});
+	}
+	const requestedIds = results.filter((r) => r.requested).map((r) => r.entry.sessionId);
+	const verification = noWait || requestedIds.length === 0
+		? null
+		: await waitForMembers(requestedIds, { paths, timeoutMs: waitTimeoutMs, baseline });
+	const ok = results.every((r) => r.requested);
+	return { ok, stage: "done", plan, results, verification };
+}
+
+/** 生成给人看的中文报告行。 */
+export function summarize(result) {
+	const lines = [];
+	if (result.stage === "preflight") {
+		lines.push("环境预检未通过，未打开任何标签页：");
+		for (const check of result.checks.filter((c) => !c.ok)) {
+			lines.push(`  ✖ ${check.name}：${check.detail}`);
+			if (check.hint) lines.push(`    → ${check.hint}`);
+		}
+		return lines;
+	}
+	const counts = {};
+	for (const item of result.plan.items) counts[item.state] = (counts[item.state] ?? 0) + 1;
+	const skipped = Object.entries(counts)
+		.filter(([state]) => state !== "restorable")
+		.map(([state, n]) => `${label(state)} ${n}`)
+		.join(" · ");
+	if (result.stage === "dry-run") {
+		lines.push(`[dry-run] 待恢复 ${result.plan.restorable.length} 个${skipped ? `；跳过：${skipped}` : ""}`);
+		for (const item of result.plan.restorable) {
+			lines.push(`  → ${item.entry.name || item.entry.sessionId} | ${item.entry.cwd}`);
+		}
+		return lines;
+	}
+	for (const r of result.results) {
+		const title = r.entry.name || r.entry.sessionId;
+		if (r.state === "claimed") {
+			lines.push(`  ⏭ ${title}：其他恢复进程正在启动，跳过`);
+		} else if (!r.requested) {
+			lines.push(`  ✖ ${title}：WezTerm 请求失败 — ${r.requestError}`);
+		} else if (result.verification?.verified.includes(r.entry.sessionId)) {
+			lines.push(`  ✔ ${title}：已启动并确认（${r.entry.cwd}）`);
+		} else {
+			lines.push(`  ⚠ ${title}：已创建标签页，超时未确认 pi 启动（${r.entry.cwd}）`);
+		}
+	}
+	const skippedText = skipped ? `；跳过：${skipped}` : "";
+	if (!result.results.length) {
+		lines.push(`没有待恢复的会话${skippedText}`);
+	} else {
+		lines.push(`已处理 ${result.results.length} 个${skippedText}`);
+	}
+	return lines;
+}

package/src/spawn.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+
+import { launchSetup, shellQuote } from "./launch.js";
+export { shellQuote } from "./launch.js";
+
+/** 登录 shell 初始化后恢复调用方 PATH 和 agent 目录，再启动已预检的 Pi。 */
+export function buildTabScript({ cwd, sessionFile, piBin, env = process.env }) {
+	return [
+		launchSetup(env, piBin),
+		`cd -- ${shellQuote(cwd)} && exec ${piBin ? shellQuote(piBin) : "pi"} --session ${shellQuote(sessionFile)}`,
+	].join("; ");
+}
+
+function defaultSpawner(program, args) {
+	return new Promise((resolve) => {
+		try {
+			const child = spawn(program, args, { detached: true, stdio: ["ignore", "pipe", "pipe"] });
+			let stdout = "";
+			let stderr = "";
+			child.stdout?.on("data", (d) => (stdout += d));
+			child.stderr?.on("data", (d) => (stderr += d));
+			const fail = (error) => resolve({ ok: false, error: String(error) });
+			child.on("error", (error) => fail(error));
+			child.on("close", (code) => {
+				if (code === 0) resolve({ ok: true, stdout: stdout.trim() });
+				else resolve({ ok: false, error: stderr.trim() || `wezterm cli 退出码 ${code}` });
+			});
+		} catch (error) {
+			resolve({ ok: false, error: String(error) });
+		}
+	});
+}
+
+/**
+ * 请求 WezTerm 打开一个标签页。返回 ok 只代表“请求被 WezTerm 接受”，
+ * 不代表 pi 已成功启动——后者由 verify 阶段确认。
+ */
+export async function openTab({ wezterm, distro, cwd, sessionFile, piBin, env = process.env, spawner } = {}) {
+	const script = buildTabScript({ cwd, sessionFile, piBin, env });
+	const args = [
+		"cli",
+		"spawn",
+		"--",
+		"wsl.exe",
+		...(distro ? ["-d", distro] : []),
+		"-e",
+		"bash",
+		"-lc",
+		script,
+	];
+	const run = spawner ?? defaultSpawner;
+	return run(wezterm, args);
+}

package/src/verify.js

@@ -0,0 +1,24 @@
+import { readMember } from "./members.js";
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * 等待被恢复的 Pi 完成登记（成员记录被新进程以新时间戳覆盖）。
+ * 只确认“pi 已启动并登记”，超时未确认的如实报告为未确认。
+ */
+export async function waitForMembers(sessionIds, { paths, timeoutMs = 15_000, pollMs = 500, baseline = Date.now(), sleeper = sleep } = {}) {
+	const pending = new Set(sessionIds);
+	const verified = new Set();
+	const deadline = Date.now() + timeoutMs;
+	while (pending.size > 0 && Date.now() < deadline) {
+		for (const id of [...pending]) {
+			const member = readMember(id, paths);
+			if (member && member.ts > baseline) {
+				verified.add(id);
+				pending.delete(id);
+			}
+		}
+		if (pending.size > 0) await sleeper(pollMs);
+	}
+	return { verified: [...verified], unverified: [...pending] };
+}