@xynogen/pix-ssh 0.1.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-ssh",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"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,10 +47,13 @@ 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,
@@ -71,6 +74,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}`;
 }
@@ -318,9 +329,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 +398,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,10 +1,12 @@
 import { describe, expect, it } from "bun:test";
 import {
 	baseSshArgs,
+	commandEscalatesPrivilege,
 	controlPathFor,
 	detectSshFailure,
 	detectSudoFailure,
 	filterSudoPrompt,
+	hostApproved,
 	hostTarget,
 	isUnreachable,
 	parseHost,
@@ -142,6 +144,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;