pi-lazy-setup 3.0.0 → 3.0.1

package/configs/pi/extensions/pi-setup.js

@@ -11,6 +11,11 @@
 //   skills   → `npx --yes skills add <repo> --skill <name> -g --agent pi -y`
 //   clis     → officecli: skill file from https://officecli.ai/SKILL.md plus
 //              binary via `curl -fsSL https://d.officecli.ai/install.sh | bash`
+//              (Windows: `irm https://d.officecli.ai/install.ps1 | iex`)
+//
+// Windows note: pi.exec spawns without a shell, so npm's .cmd shims (pi,
+// npx) cannot be launched directly — every command is routed through
+// `cmd.exe /c`, the same workaround rpiv-pi's /rpiv-setup uses.
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -27,8 +32,18 @@ function globalSkillsDir() {
 
 const INSTALL_TIMEOUT_MS = 300_000;
 const BIN_CHECK_TIMEOUT_MS = 15_000;
+const DOWNLOAD_TIMEOUT_MS = 120_000;
 const STDERR_SNIPPET_CHARS = 300;
 
+// Read at call time (not module load) so tests can simulate win32.
+function isWindows() {
+	return process.platform === "win32";
+}
+
+// Reference to the running ExtensionAPI, captured by the factory and used by
+// the curl fallback in downloadSkillFile.
+let piRef = null;
+
 /** Pi extension packages offered via `pi install <source>`. */
 const PACKAGES = [
 	{ source: "npm:pi-footer", description: "Footer status line (token usage, model, cost)." },
@@ -58,11 +73,16 @@ const CLIS = [
 		bin: "officecli",
 		description: "AI-friendly CLI for Office documents (.docx/.xlsx/.pptx).",
 		skillFile: { name: "officecli", url: "https://officecli.ai/SKILL.md" },
+		// macOS/Linux — official install script
 		installCommand: "curl -fsSL https://d.officecli.ai/install.sh | bash",
+		// Windows — official PowerShell install (officecli SKILL.md documents both)
+		installCommandWindows: "irm https://d.officecli.ai/install.ps1 | iex",
 	},
 ];
 
 export default function piSetupExtension(pi) {
+	// captured for the curl fallback in downloadSkillFile
+	piRef = pi;
 	pi.registerCommand("pi-setup", {
 		description: "Install packages, skills, and CLI tools (each confirmed individually)",
 		handler: async (_args, ctx) => {
@@ -150,28 +170,55 @@ async function installClis(pi, ctx, report) {
 		if (await binaryAvailable(pi, c.bin)) {
 			report.skipped.push(`cli:${c.bin}`);
 		} else {
-			const confirmed = await ctx.ui.confirm("Install CLI tool?", `${c.id} — ${c.description}\n${c.installCommand}`);
+			const installCmd = isWindows() ? (c.installCommandWindows ?? c.installCommand) : c.installCommand;
+			const confirmed = await ctx.ui.confirm("Install CLI tool?", `${c.id} — ${c.description}\n${installCmd}`);
 			if (confirmed) {
 				ctx.ui.notify(`Installing ${c.id}…`, "info");
-				const result = await runExec(pi, "bash", ["-c", c.installCommand]);
+				// macOS/Linux: run the piped install script via bash -c.
+				// Windows: powershell.exe is a real binary — spawn it DIRECTLY
+				// (runExecDirect), because routing "… | …" through cmd.exe /c
+				// would let cmd parse the pipe itself.
+				const result = isWindows()
+					? await runExecDirect(pi, "powershell", ["-NoProfile", "-Command", installCmd])
+					: await runExec(pi, "bash", ["-c", installCmd]);
 				settle(result, `cli:${c.bin}`, report);
 			}
 		}
 	}
 }
 
-/** Run a command via pi.exec and normalize into { ok, error }. */
+/**
+ * Run a command via pi.exec and normalize into { ok, error }.
+ *
+ * On Windows, pi.exec's shell-less spawn cannot launch npm's .cmd shims
+ * (`pi`, `npx`) — the classic ENOENT trap (see rpiv-pi's pi-installer.ts) —
+ * so commands are routed through `cmd.exe /c`. Use runExecDirect for real
+ * .exe binaries whose arguments must NOT be re-parsed by cmd.exe
+ * (e.g. powershell -Command "… | …").
+ */
 async function runExec(pi, command, args, timeoutMs = INSTALL_TIMEOUT_MS) {
+	const { cmd, cmdArgs } = resolveCommand(command, args);
+	return runExecDirect(pi, cmd, cmdArgs, timeoutMs);
+}
+
+/** Run an exact command (no Windows cmd.exe re-parsing) and normalize into { ok, error }. */
+async function runExecDirect(pi, cmd, cmdArgs, timeoutMs = INSTALL_TIMEOUT_MS) {
 	try {
-		const result = await pi.exec(command, args, { timeout: timeoutMs });
+		const result = await pi.exec(cmd, cmdArgs, { timeout: timeoutMs });
 		if (result.code === 0) return { ok: true };
 		const error = (result.stderr || result.stdout || `exit ${result.code}`).trim().slice(0, STDERR_SNIPPET_CHARS);
-		return { ok: false, error };
+		return { ok: false, error: `${cmd} ${cmdArgs.join(" ")}: ${error}` };
 	} catch (err) {
 		return { ok: false, error: toMessage(err) };
 	}
 }
 
+/** Windows: route through cmd.exe (spawns .cmd shims, provides shell). */
+function resolveCommand(command, args) {
+	if (!isWindows()) return { cmd: command, cmdArgs: args };
+	return { cmd: "cmd.exe", cmdArgs: ["/c", command, ...args] };
+}
+
 function settle(result, item, report) {
 	if (result.ok) report.installed.push(item);
 	else report.failed.push({ item, error: result.error });
@@ -196,19 +243,59 @@ async function binaryAvailable(pi, name) {
 	const result = await runExec(pi, name, ["--version"], BIN_CHECK_TIMEOUT_MS);
 	return result.ok;
 }
-
-/** Download a SKILL.md into ~/.agents/skills/<name>/SKILL.md. */
+/**
+ * Download a SKILL.md into ~/.agents/skills/<name>/SKILL.md.
+ *
+ * Tries global fetch first; on failure falls back to curl so environments
+ * where fetch fails (no direct network, system proxy that fetch ignores) can
+ * still reach the URL — curl honors http_proxy/https_proxy env vars.
+ */
 async function downloadSkillFile(name, url) {
-	const res = await fetch(url);
-	if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${url}`);
-	const text = await res.text();
+	const fetchError = await tryFetchSkillFile(name, url);
+	if (fetchError === null) return;
+	// curl fallback
+	const curlArgs = ["-fsSL", "--max-time", "120", url];
+	const { cmd, cmdArgs } = resolveCommand("curl", curlArgs);
+	const result = await piExecDownload(cmd, cmdArgs);
+	if (result === null) throw new Error(`${toMessage(fetchError)} (curl fallback also failed)`);
 	const dir = join(globalSkillsDir(), name);
 	mkdirSync(dir, { recursive: true });
-	writeFileSync(join(dir, "SKILL.md"), text);
+	writeFileSync(join(dir, "SKILL.md"), result);
+}
+
+/** Fetch + write the SKILL.md. Returns null on success, the error otherwise. */
+async function tryFetchSkillFile(name, url) {
+	try {
+		const res = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+		if (!res.ok) return new Error(`HTTP ${res.status} fetching ${url}`);
+		const text = await res.text();
+		const dir = join(globalSkillsDir(), name);
+		mkdirSync(dir, { recursive: true });
+		writeFileSync(join(dir, "SKILL.md"), text);
+		return null;
+	} catch (err) {
+		return err;
+	}
+}
+
+/** Fetch a URL body via curl through pi.exec. Returns null on failure. */
+async function piExecDownload(cmd, cmdArgs) {
+	if (!piRef) return null;
+	try {
+		const result = await piRef.exec(cmd, cmdArgs, { timeout: DOWNLOAD_TIMEOUT_MS });
+		if (result.code !== 0) return null;
+		return result.stdout;
+	} catch {
+		return null;
+	}
 }
 
 function toMessage(err) {
-	return String(err?.message ?? err);
+	const msg = String(err?.message ?? err);
+	// "fetch failed" alone is useless — surface the underlying cause
+	// (DNS, TLS, connect timeout, …) when Node attached one.
+	const cause = err?.cause?.code ?? err?.cause?.message;
+	return cause ? `${msg} (${cause})` : msg;
 }
 
 function buildReport(report) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lazy-setup",
-	"version": "3.0.0",
+	"version": "3.0.1",
 	"description": "Initialize the Pi agent environment from a curated snapshot",
 	"type": "module",
 	"bin": {