@xynogen/pix-ssh 0.5.2 → 0.5.6

package/README.md

@@ -49,16 +49,22 @@ Completed calls collapse after the configured Pix delay into a status row such a
 pi install npm:@xynogen/pix-ssh
 ```
 
-> Standalone/opt-in — **not** bundled by [`@xynogen/pix-core`](https://www.npmjs.com/package/@xynogen/pix-core). Remote execution over SSH is a networked, privileged capability, so you install it deliberately.
+> Standalone and opt-in. [`@xynogen/pix-core`](https://www.npmjs.com/package/@xynogen/pix-core) does not bundle it. Remote execution over SSH is a networked, privileged capability.
 
 ## Full distro
 
-Source: [github.com/xynogen/pix-mono](https://github.com/xynogen/pix-mono)
+This package is part of [Pix](https://github.com/xynogen/pix-mono). The installer sets up Pi and the full distro. See [Install](https://github.com/xynogen/pix-mono#install) for the notes for each OS.
 
 ```bash
+# Linux / macOS
 curl -fsSL https://raw.githubusercontent.com/xynogen/pix-mono/main/scripts/install.sh | sh
 ```
 
+```powershell
+# Windows
+irm https://raw.githubusercontent.com/xynogen/pix-mono/main/scripts/install.ps1 | iex
+```
+
 ## License
 
-MIT
+MIT. See [LICENSE](LICENSE).

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@xynogen/pix-ssh",
-	"version": "0.5.2",
-	"description": "Pi tool — ssh_run: run remote commands over SSH with password/key auth and remote sudo",
+	"version": "0.5.6",
+	"description": "Pi tool \u2014 ssh_run: run remote commands over SSH with password/key auth and remote sudo",
 	"type": "module",
 	"main": "src/index.ts",
 	"scripts": {
@@ -37,11 +37,11 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"typebox": "^1.1.38",
-		"@xynogen/pix-pretty": "^1.25.0",
-		"@xynogen/pix-runtime": "^0.8.0"
+		"@xynogen/pix-pretty": "^1.30.0",
+		"@xynogen/pix-runtime": "^0.13.0"
 	},
 	"peerDependencies": {
+		"typebox": "*",
 		"@earendil-works/pi-coding-agent": "*",
 		"@earendil-works/pi-tui": "*"
 	}

package/src/index.ts

@@ -27,28 +27,34 @@
 
 import type { AgentToolUpdateCallback, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { FG_DIM, RST, resolveBaseBackground } from "@xynogen/pix-pretty/ansi";
+import { resolveBaseBackground } from "@xynogen/pix-pretty/ansi";
+import { collapsedCommandRow, commandPreview } from "@xynogen/pix-pretty/command-preview";
 import { MAX_PREVIEW_LINES } from "@xynogen/pix-pretty/config";
 import { type OverlayResult, showOverlay } from "@xynogen/pix-pretty/gate-overlay";
 import { icon } from "@xynogen/pix-pretty/icon-catalog";
 import { renderBashOutput } from "@xynogen/pix-pretty/renderers";
 import type { RenderContextLike, ThemeLike, ToolResultLike } from "@xynogen/pix-pretty/types";
 import {
+	BODY_PAD,
+	bodyLine,
 	dotJoin,
 	fillToolBackground,
+	formatCollapsedToolRow,
+	formatToolCallTitle,
 	frameToolResult,
+	getErrorMessage,
 	getTextContent,
 	hideCollapsedToolCall,
+	moreLines,
 	normalizeLineEndings,
-	renderCollapsedToolRow,
 	renderToolError,
 	ruleFrame,
-	sectionRule,
 	termW,
 	unframeToolResult,
 } from "@xynogen/pix-pretty/utils";
 import { SPINNER } from "@xynogen/pix-pretty/widget-format";
 import { getUnattendedMode, withAgentBlock } from "@xynogen/pix-runtime";
+import { requireTool } from "@xynogen/pix-runtime/binaries";
 import { type CollapseState, tickCollapse } from "@xynogen/pix-runtime/collapse";
 import { Type } from "typebox";
 import {
@@ -351,6 +357,22 @@ function formatAliasList(aliases: HostAlias[]): string {
  * given, otherwise the alias inventory from ~/.ssh/config. Read-only.
  * Details carry `_type: "sshInfo"` so renderResult falls to its generic
  * plain-text branch (no collapse, no exit-code framing). */
+/**
+ * The pix-runtime lookup message for the first missing binary this action
+ * needs (ssh, plus scp for file transfers), or undefined when all resolve.
+ * sshpass is checked lazily: it only matters when a login password is used.
+ */
+export function missingSshTools(action: "command" | "file"): string | undefined {
+	for (const name of action === "file" ? ["ssh", "scp"] : ["ssh"]) {
+		try {
+			requireTool(name);
+		} catch (err) {
+			return getErrorMessage(err);
+		}
+	}
+	return undefined;
+}
+
 async function infoResult(host: string | undefined, sig?: AbortSignal) {
 	const details = { _type: "sshInfo" as const };
 	if (host?.trim()) {
@@ -358,7 +380,7 @@ async function infoResult(host: string | undefined, sig?: AbortSignal) {
 		try {
 			spec = parseHost(host);
 		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
+			const msg = getErrorMessage(err);
 			return {
 				content: [{ type: "text" as const, text: `ssh_run failed: ${msg}` }],
 				details,
@@ -379,6 +401,7 @@ async function infoResult(host: string | undefined, sig?: AbortSignal) {
 export default function (pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "ssh_run",
+		...({ exposure: "deferred" } as const),
 		label: "Run over SSH",
 		description:
 			"Run a command or transfer files/directories on a REMOTE host over SSH. " +
@@ -496,11 +519,25 @@ export default function (pi: ExtensionAPI): void {
 				};
 			}
 
+			// Fail up front with pix's install hint: the probes below treat a spawn
+			// error as "unreachable", which would hide a missing ssh/scp.
+			const missingTool = missingSshTools(action);
+			if (missingTool) {
+				return {
+					content: [{ type: "text", text: `ssh_run failed: ${missingTool}` }],
+					details: makeDetails(command, params.host, sudo, reason, {
+						outcome: "error",
+						errorKind: "execution",
+					}),
+					isError: true,
+				};
+			}
+
 			let spec: HostSpec;
 			try {
 				spec = parseHost(params.host);
 			} catch (err) {
-				const msg = err instanceof Error ? err.message : String(err);
+				const msg = getErrorMessage(err);
 				return {
 					content: [{ type: "text", text: `ssh_run failed: ${msg}` }],
 					details: makeDetails(command, params.host, sudo, reason, {
@@ -750,7 +787,7 @@ export default function (pi: ExtensionAPI): void {
 								...(sig ? { signal: sig } : {}),
 							});
 			} catch (err) {
-				const msg = err instanceof Error ? err.message : String(err);
+				const msg = getErrorMessage(err);
 				return {
 					content: [{ type: "text", text: `ssh_run failed: ${msg}` }],
 					details: makeDetails(
@@ -851,20 +888,23 @@ export default function (pi: ExtensionAPI): void {
 			if (args.action === "info") {
 				text.setText(
 					fillToolBackground(
-						`${theme.fg("toolTitle", theme.bold("ssh info"))} ${theme.fg("dim", host || "list aliases")}`,
+						`${formatToolCallTitle(theme, "ssh info", renderCtx)} ${theme.fg("dim", host || "list aliases")}`,
 					),
 				);
 				return text;
 			}
 			const operation = normalizeOperation(args);
-			const command = safeOneLine(operation.command) || "(empty command)";
+			const command = operation.command || "(empty command)";
 			const prefix = operation.sudo ? "sudo " : "";
-			text.setText(
-				fillToolBackground(
-					`${theme.fg("toolTitle", theme.bold(operation.action === "file" ? "ssh file" : "ssh"))} ${theme.fg("dim", host)} ${theme.fg("muted", prefix + command)}`,
-				),
+			return commandPreview(
+				`${formatToolCallTitle(theme, operation.action === "file" ? "ssh file" : "ssh", renderCtx)} ${theme.fg("dim", host)}`,
+				prefix + command,
+				"bash",
+				theme,
+				renderCtx.state,
+				renderCtx.invalidate,
+				renderCtx.expanded,
 			);
-			return text;
 		}) as never,
 
 		renderResult: ((
@@ -884,7 +924,7 @@ export default function (pi: ExtensionAPI): void {
 					text.setText(renderToolError(getTextContent(result) || "Error", theme));
 				} else {
 					text.setText(
-						fillToolBackground(`  ${theme.fg("muted", getTextContent(result) || "done")}`),
+						fillToolBackground(`${BODY_PAD}${theme.fg("muted", getTextContent(result) || "done")}`),
 					);
 				}
 				return isPartial ? text : completed(renderCtx.isError);
@@ -901,21 +941,24 @@ export default function (pi: ExtensionAPI): void {
 				)
 			) {
 				const status = details.outcome === "success" ? "success" : "error";
-				text.setText(
-					renderCollapsedToolRow(
+				return collapsedCommandRow(
+					formatCollapsedToolRow(
 						theme,
 						"ssh",
-						`${details.host}  ${safeOneLine(details.command)}`,
+						details.host,
 						terminalMeta(details),
 						status,
-					),
+					).trimEnd(),
+					safeOneLine(details.command),
+					theme,
 				);
-				return text;
 			}
 
 			if (details.outcome === "awaiting-approval" || details.outcome === "running") {
 				text.setText(
-					fillToolBackground(`  ${theme.fg("muted", getTextContent(result) || "working")}`),
+					fillToolBackground(
+						`${BODY_PAD}${theme.fg("muted", getTextContent(result) || "working")}`,
+					),
 				);
 				return text;
 			}
@@ -925,7 +968,7 @@ export default function (pi: ExtensionAPI): void {
 				text.setText(
 					details.outcome === "error"
 						? renderToolError(diagnostic, theme)
-						: fillToolBackground(`  ${theme.fg("warning", diagnostic)}`),
+						: fillToolBackground(`${BODY_PAD}${theme.fg("warning", diagnostic)}`),
 				);
 				return isPartial ? text : completed(true);
 			}
@@ -937,18 +980,16 @@ export default function (pi: ExtensionAPI): void {
 			const lineCount = lines.length;
 
 			if (!rendered) {
-				text.setText(fillToolBackground(`  ${summary}`));
+				text.setText(fillToolBackground(`${BODY_PAD}${summary}`));
 				return isPartial ? text : completed(details.outcome !== "success");
 			}
 
 			const maxShow = renderCtx.expanded ? lineCount : MAX_PREVIEW_LINES;
 			const show = lines.slice(0, maxShow);
-			const footer =
-				lineCount > maxShow ? [`${FG_DIM}  … ${lineCount - maxShow} more lines${RST}`] : [];
+			const footer = lineCount > maxShow ? [moreLines(lineCount - maxShow, theme)] : [];
 			const statusKey = details.outcome === "success" ? "success" : "error";
 			const paint = (s: string) => theme.fg(statusKey, s);
-			const sw = Math.max(8, termW() - 4); // section-rule width inside the 2-space indent
-			const body = show.map((line) => `  ${sectionRule(line, theme, sw) ?? line}`);
+			const body = show.map((line) => bodyLine(line, theme));
 			const out = isPartial ? [...body, ...footer] : ruleFrame(body, footer, termW(), paint);
 			text.setText(fillToolBackground(out.join("\n")));
 			return text;

package/src/lib.ts

@@ -13,14 +13,21 @@
  *     entered once per session per host.
  */
 
-import { spawn } from "node:child_process";
+import type { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { globSync, readFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
 import { isAbsolute, join, resolve as resolvePath } from "node:path";
-
-export const MAX_OUTPUT_BYTES = 50 * 1024;
-export const MAX_OUTPUT_LINES = 2000;
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	truncateHead,
+} from "@earendil-works/pi-coding-agent";
+import { spawnTool } from "@xynogen/pix-runtime/exec";
+import { expandHome, homeDir, tempDir } from "@xynogen/pix-runtime/paths";
+
+// Pi's own tool-output limits (50KB / 2000 lines), so every tool caps the same way.
+export const MAX_OUTPUT_BYTES = DEFAULT_MAX_BYTES;
+export const MAX_OUTPUT_LINES = DEFAULT_MAX_LINES;
 
 /** Per-host approval TTL (ms) — mirrors sudo's PAM ticket window (~15 min). */
 export const APPROVAL_TTL_MS = 15 * 60_000;
@@ -144,7 +151,7 @@ export function resolveSshHost(spec: HostSpec, signal?: AbortSignal): Promise<Ho
 
 	return new Promise((resolve) => {
 		let stdout = "";
-		const proc = spawn("ssh", args, { stdio: ["ignore", "pipe", "ignore"] });
+		const proc = spawnTool("ssh", args, { stdio: ["ignore", "pipe", "ignore"] });
 		proc.stdout.on("data", (chunk: Buffer) => {
 			stdout += chunk.toString();
 		});
@@ -216,9 +223,7 @@ export function parseHostAliases(text: string): HostAlias[] {
 /** Expand a Path with a leading `~` and resolve relative Includes against
  * the containing config's directory (OpenSSH semantics). */
 function expandConfigPath(pattern: string, baseDir: string): string {
-	let p = pattern;
-	if (p.startsWith("~/")) p = join(homedir(), p.slice(2));
-	else if (p === "~") p = homedir();
+	const p = expandHome(pattern);
 	return isAbsolute(p) ? p : resolvePath(baseDir, p);
 }
 
@@ -228,7 +233,7 @@ function expandConfigPath(pattern: string, baseDir: string): string {
  * (OpenSSH tolerates them). `seen` guards against Include cycles.
  */
 export function readSshConfigAliases(
-	path = join(homedir(), ".ssh", "config"),
+	path = join(homeDir(), ".ssh", "config"),
 	seen = new Set<string>(),
 ): HostAlias[] {
 	if (seen.has(path)) return [];
@@ -239,7 +244,7 @@ export function readSshConfigAliases(
 	} catch {
 		return [];
 	}
-	const baseDir = join(homedir(), ".ssh");
+	const baseDir = join(homeDir(), ".ssh");
 	const out: HostAlias[] = [];
 	for (const raw of text.split("\n")) {
 		const line = raw.replace(/#.*$/, "").trim();
@@ -280,7 +285,7 @@ export function resolveHostInfo(spec: HostSpec, signal?: AbortSignal): Promise<H
 	args.push(hostTarget(spec));
 	return new Promise((resolve) => {
 		let stdout = "";
-		const proc = spawn("ssh", args, { stdio: ["ignore", "pipe", "ignore"] });
+		const proc = spawnTool("ssh", args, { stdio: ["ignore", "pipe", "ignore"] });
 		proc.stdout.on("data", (c: Buffer) => {
 			stdout += c.toString();
 		});
@@ -300,7 +305,7 @@ export function hostTarget(spec: HostSpec): string {
 export function controlPathFor(spec: HostSpec): string {
 	const key = `${spec.user ?? ""}@${spec.host}:${spec.port ?? 22}`;
 	const hash = createHash("sha256").update(key).digest("hex").slice(0, 16);
-	return join(tmpdir(), `pix-ssh-${hash}.sock`);
+	return join(tempDir(), `pix-ssh-${hash}.sock`);
 }
 
 // ── ssh argv construction ────────────────────────────────────────────────────
@@ -405,17 +410,12 @@ export function truncate(
 	maxLines = MAX_OUTPUT_LINES,
 	maxBytes = MAX_OUTPUT_BYTES,
 ): { text: string; truncated: boolean } {
-	const lines = text.split("\n");
-	const byteLen = Buffer.byteLength(text, "utf8");
-	if (lines.length <= maxLines && byteLen <= maxBytes) {
-		return { text, truncated: false };
-	}
-	const kept = lines.slice(0, maxLines);
-	let result = kept.join("\n");
-	if (Buffer.byteLength(result, "utf8") > maxBytes) {
-		result = Buffer.from(result, "utf8").subarray(0, maxBytes).toString("utf8");
-	}
-	return { text: result, truncated: true };
+	const r = truncateHead(text, { maxLines, maxBytes });
+	if (!r.firstLineExceedsLimit) return { text: r.content, truncated: r.truncated };
+	// One line over the byte cap (minified JSON, a base64 blob): truncateHead keeps
+	// nothing. Keep its first maxBytes instead, cut on a UTF-8 boundary.
+	const head = Buffer.from(text, "utf8").subarray(0, maxBytes).toString("utf8");
+	return { text: head.replace(/\uFFFD$/, ""), truncated: true };
 }
 
 // ── Runners ──────────────────────────────────────────────────────────────────
@@ -440,7 +440,7 @@ export function probeKeyAuth(
 	const args = [...baseSshArgs(spec, controlPath), "-o", "BatchMode=yes", hostTarget(spec), "true"];
 	return new Promise((resolve) => {
 		let stderr = "";
-		const proc = spawn("ssh", args, { stdio: ["ignore", "ignore", "pipe"] });
+		const proc = spawnTool("ssh", args, { stdio: ["ignore", "ignore", "pipe"] });
 		proc.stderr.on("data", (c: Buffer) => {
 			stderr += c.toString();
 		});
@@ -488,7 +488,7 @@ export function probePasswordAuth(
 	];
 	return new Promise((resolve) => {
 		let stderr = "";
-		const proc = spawn("sshpass", args, {
+		const proc = spawnTool("sshpass", args, {
 			stdio: ["ignore", "ignore", "pipe"],
 			env: { ...process.env, SSHPASS: password },
 		});
@@ -525,7 +525,7 @@ export function probeSudoNoPassword(
 		"sudo -n true",
 	];
 	return new Promise((resolve) => {
-		const proc = spawn("ssh", args, { stdio: ["ignore", "ignore", "ignore"] });
+		const proc = spawnTool("ssh", args, { stdio: ["ignore", "ignore", "ignore"] });
 		proc.on("error", () => resolve(false));
 		proc.on("close", (code) => resolve(code === 0));
 		signal?.addEventListener("abort", () => proc.kill("SIGTERM"), { once: true });
@@ -621,7 +621,7 @@ function spawnResult(
 	stdin?: string,
 ): Promise<SshResult> {
 	return new Promise((resolve, reject) => {
-		const proc = spawn(bin, args, { stdio: ["pipe", "pipe", "pipe"], env });
+		const proc = spawnTool(bin, args, { stdio: ["pipe", "pipe", "pipe"], env });
 		let stdout = "";
 		let stderr = "";
 		proc.stdout.on("data", (c: Buffer) => {