@xynogen/pix-ssh 0.1.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-ssh",
-	"version": "0.1.0",
+	"version": "0.2.2",
 	"description": "Pi tool — ssh_run: run remote commands over SSH with password/key auth and remote sudo",
 	"type": "module",
 	"main": "src/index.ts",

package/src/index.ts

@@ -47,15 +47,19 @@ import { withAgentBlock } from "@xynogen/pix-runtime";
 import { type CollapseState, tickCollapse } from "@xynogen/pix-runtime/collapse";
 import { Type } from "typebox";
 import {
+	APPROVAL_TTL_MS,
+	commandEscalatesPrivilege,
 	controlPathFor,
 	detectSshFailure,
 	detectSudoFailure,
 	type HostSpec,
+	hostApproved,
 	hostTarget,
 	MAX_OUTPUT_BYTES,
 	MAX_OUTPUT_LINES,
 	parseHost,
 	probeKeyAuth,
+	resolveSshHost,
 	runSsh,
 	truncate,
 } from "./lib.ts";
@@ -71,6 +75,14 @@ interface HostCreds {
 }
 const credCache = new Map<string, HostCreds>();
 
+// Per-host allow-memory (on by default): once the user approves any command on
+// a host, later calls to that host skip the confirm overlay until the approval
+// expires — mirroring sudo's PAM ticket window (~15 min), not the whole session.
+// Password prompts are NOT skipped — a still-missing login or sudo password
+// always re-prompts. Each auto-approve emits a visible notify so the decision is
+// never silent. Map value = epoch ms when the approval lapses (see APPROVAL_TTL_MS).
+const approvedHosts = new Map<string, number>();
+
 function cacheKey(spec: HostSpec): string {
 	return `${spec.user ?? ""}@${spec.host}:${spec.port ?? 22}`;
 }
@@ -257,9 +269,14 @@ export default function (pi: ExtensionAPI): void {
 					isError: true,
 				};
 			}
-			const host = hostTarget(spec);
-			const controlPath = controlPathFor(spec);
-			const key = cacheKey(spec);
+			// ponytail: let OpenSSH own config parsing; `ssh -G` handles aliases,
+			// Include, and Match rules without duplicating its config grammar.
+			const effectiveSpec = await resolveSshHost(spec, sig);
+			const host = hostTarget(effectiveSpec);
+			// Keep original target for execution so alias-specific IdentityFile,
+			// ProxyJump, and other SSH config options still apply.
+			const controlPath = controlPathFor(effectiveSpec);
+			const key = cacheKey(effectiveSpec);
 			const creds = credCache.get(key) ?? {};
 
 			const g = globalThis as { __pixAfk?: boolean; __pixYolo?: boolean };
@@ -318,9 +335,20 @@ export default function (pi: ExtensionAPI): void {
 			// pix-sudo uses (masked input, N attempts). We can't validate remote
 			// passwords without connecting, so validatePassword just accepts a
 			// non-empty entry; a wrong password surfaces as an auth error after run.
+			// Session allow-memory: host already approved + no password missing → skip
+			// the confirm overlay entirely (visible notify below). Privileged commands
+			// (sudo:true, or a sudo/su/doas/pkexec token in the command text) are never
+			// auto-approved — they always re-confirm.
+			const privileged = sudo || commandEscalatesPrivilege(command);
+			const alreadyApproved =
+				!privileged && hostApproved(approvedHosts, key) && promptFor.length === 0;
+			if (alreadyApproved) {
+				ctx.ui.notify(`🔐 ssh_run auto-approved — ${host} allowed this session`, "warning");
+			}
+
 			const runOverlay = (): Promise<OverlayResult> =>
 				withAgentBlock(pi.events, "ssh_run", "SSH approval required", async () => {
-					if (yolo && promptFor.length === 0) {
+					if ((yolo || alreadyApproved) && promptFor.length === 0) {
 						return { action: "approved", password: "" } as OverlayResult;
 					}
 					// Confirm-only when no password is missing.
@@ -376,6 +404,9 @@ export default function (pi: ExtensionAPI): void {
 				return r;
 			}
 
+			// Remember this host's approval until the TTL lapses (refreshed each call).
+			approvedHosts.set(key, Date.now() + APPROVAL_TTL_MS);
+
 			// Persist newly-entered passwords in the session cache.
 			const loginPassword = creds.loginPassword ?? collected.login;
 			const sudoPassword = creds.sudoPassword ?? collected.sudo;

package/src/lib.test.ts

@@ -1,13 +1,16 @@
 import { describe, expect, it } from "bun:test";
 import {
 	baseSshArgs,
+	commandEscalatesPrivilege,
 	controlPathFor,
 	detectSshFailure,
 	detectSudoFailure,
 	filterSudoPrompt,
+	hostApproved,
 	hostTarget,
 	isUnreachable,
 	parseHost,
+	parseSshConfig,
 	remoteCommand,
 	shellQuote,
 	truncate,
@@ -44,6 +47,20 @@ describe("parseHost", () => {
 	});
 });
 
+describe("parseSshConfig", () => {
+	it("reads effective user, hostname, and port from ssh -G output", () => {
+		expect(parseSshConfig("host orin\nuser jetson\nhostname 10.10.21.251\nport 2222\n")).toEqual({
+			user: "jetson",
+			host: "10.10.21.251",
+			port: 2222,
+		});
+	});
+
+	it("rejects incomplete ssh -G output", () => {
+		expect(parseSshConfig("hostname 10.10.21.251\n")).toBeUndefined();
+	});
+});
+
 describe("hostTarget", () => {
 	it("joins user and host", () => {
 		expect(hostTarget({ user: "a", host: "b" })).toBe("a@b");
@@ -142,6 +159,36 @@ describe("filterSudoPrompt", () => {
 	});
 });
 
+describe("hostApproved", () => {
+	it("is false for an unknown host", () => {
+		expect(hostApproved(new Map(), "u@h:22")).toBe(false);
+	});
+	it("is true within the TTL window", () => {
+		const m = new Map([["u@h:22", 1000]]);
+		expect(hostApproved(m, "u@h:22", 500)).toBe(true);
+	});
+	it("expires and self-prunes at/after the deadline", () => {
+		const m = new Map([["u@h:22", 1000]]);
+		expect(hostApproved(m, "u@h:22", 1000)).toBe(false);
+		expect(m.has("u@h:22")).toBe(false);
+	});
+});
+
+describe("commandEscalatesPrivilege", () => {
+	it("flags leading and mid-chain escalation tokens", () => {
+		expect(commandEscalatesPrivilege("sudo apt update")).toBe(true);
+		expect(commandEscalatesPrivilege("apt update && sudo apt install x")).toBe(true);
+		expect(commandEscalatesPrivilege("foo; su -c 'x'")).toBe(true);
+		expect(commandEscalatesPrivilege("doas reboot")).toBe(true);
+		expect(commandEscalatesPrivilege("pkexec whoami")).toBe(true);
+	});
+	it("does not flag plain commands or substrings", () => {
+		expect(commandEscalatesPrivilege("ls -la")).toBe(false);
+		expect(commandEscalatesPrivilege("pseudo-tty")).toBe(false);
+		expect(commandEscalatesPrivilege("cat sudoku.txt")).toBe(false);
+	});
+});
+
 describe("truncate", () => {
 	it("passes short text through", () => {
 		expect(truncate("a\nb").truncated).toBe(false);

package/src/lib.ts

@@ -21,6 +21,33 @@ import { join } from "node:path";
 export const MAX_OUTPUT_BYTES = 50 * 1024;
 export const MAX_OUTPUT_LINES = 2000;
 
+/** Per-host approval TTL (ms) — mirrors sudo's PAM ticket window (~15 min). */
+export const APPROVAL_TTL_MS = 15 * 60_000;
+
+/**
+ * True when `key` has a live (non-expired) approval in `map`; deletes the entry
+ * on expiry so the map self-prunes. `now` is injectable for tests.
+ */
+export function hostApproved(map: Map<string, number>, key: string, now = Date.now()): boolean {
+	const expiry = map.get(key);
+	if (expiry === undefined) return false;
+	if (now >= expiry) {
+		map.delete(key);
+		return false;
+	}
+	return true;
+}
+
+/**
+ * True when the command text itself escalates privilege (sudo/su/doas/pkexec),
+ * so per-host allow-memory must NOT auto-approve it even when `sudo:true` was
+ * not passed. Word-boundary match; catches leading and mid-chain occurrences
+ * (`… && sudo …`).
+ */
+export function commandEscalatesPrivilege(command: string): boolean {
+	return /(^|[\s;&|(])(sudo|su|doas|pkexec)\b/.test(command);
+}
+
 /** ControlPersist window (seconds) — the multiplexed connection lingers this
  * long after the last call, so repeat commands skip re-auth. */
 const CONTROL_PERSIST_SECONDS = 120;
@@ -81,6 +108,39 @@ function parsePort(value: string): number {
 	return n;
 }
 
+/** Parse effective destination fields emitted by OpenSSH's `ssh -G`. */
+export function parseSshConfig(output: string): HostSpec | undefined {
+	const values = new Map(
+		output
+			.split("\n")
+			.map((line) => line.trim().split(/\s+/, 2))
+			.filter((parts): parts is [string, string] => parts.length === 2),
+	);
+	const user = values.get("user");
+	const host = values.get("hostname");
+	const port = values.get("port");
+	if (!user || !host || !port) return undefined;
+	return { user, host, port: parsePort(port) };
+}
+
+/** Resolve aliases through OpenSSH config, including Include and Match rules. */
+export function resolveSshHost(spec: HostSpec, signal?: AbortSignal): Promise<HostSpec> {
+	const args = ["-G"];
+	if (spec.port !== undefined) args.push("-p", String(spec.port));
+	args.push(hostTarget(spec));
+
+	return new Promise((resolve) => {
+		let stdout = "";
+		const proc = spawn("ssh", args, { stdio: ["ignore", "pipe", "ignore"] });
+		proc.stdout.on("data", (chunk: Buffer) => {
+			stdout += chunk.toString();
+		});
+		proc.on("error", () => resolve(spec));
+		proc.on("close", (code) => resolve(code === 0 ? (parseSshConfig(stdout) ?? spec) : spec));
+		signal?.addEventListener("abort", () => proc.kill("SIGTERM"), { once: true });
+	});
+}
+
 /** Canonical `[user@]host` target string for ssh argv. */
 export function hostTarget(spec: HostSpec): string {
 	return spec.user ? `${spec.user}@${spec.host}` : spec.host;