@oh-my-pi/pi-coding-agent 3.32.0 → 3.34.0

package/src/core/ssh/sshfs-mount.ts

@@ -0,0 +1,162 @@
+import { chmodSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME } from "../../config";
+import { logger } from "../logger";
+import { getControlDir, getControlPathTemplate, type SSHConnectionTarget } from "./connection-manager";
+
+const REMOTE_DIR = join(homedir(), CONFIG_DIR_NAME, "remote");
+const CONTROL_DIR = getControlDir();
+const CONTROL_PATH = getControlPathTemplate();
+
+const mountedPaths = new Set<string>();
+
+function ensureDir(path: string, mode = 0o700): void {
+	if (!existsSync(path)) {
+		mkdirSync(path, { recursive: true, mode });
+	}
+	try {
+		chmodSync(path, mode);
+	} catch (err) {
+		logger.debug("SSHFS dir chmod failed", { path, error: String(err) });
+	}
+}
+
+function decodeOutput(buffer?: Uint8Array): string {
+	if (!buffer || buffer.length === 0) return "";
+	return new TextDecoder().decode(buffer).trim();
+}
+
+function getMountName(host: SSHConnectionTarget): string {
+	const raw = (host.name ?? host.host).trim();
+	const sanitized = raw.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	return sanitized.length > 0 ? sanitized : "remote";
+}
+
+function getMountPath(host: SSHConnectionTarget): string {
+	return join(REMOTE_DIR, getMountName(host));
+}
+
+function buildSshTarget(host: SSHConnectionTarget): string {
+	return host.username ? `${host.username}@${host.host}` : host.host;
+}
+
+function buildSshfsArgs(host: SSHConnectionTarget): string[] {
+	const args = [
+		"-o",
+		"reconnect",
+		"-o",
+		"ServerAliveInterval=15",
+		"-o",
+		"ServerAliveCountMax=3",
+		"-o",
+		"BatchMode=yes",
+		"-o",
+		"StrictHostKeyChecking=accept-new",
+		"-o",
+		"ControlMaster=auto",
+		"-o",
+		`ControlPath=${CONTROL_PATH}`,
+		"-o",
+		"ControlPersist=3600",
+	];
+
+	if (host.port) {
+		args.push("-p", String(host.port));
+	}
+
+	if (host.keyPath) {
+		args.push("-o", `IdentityFile=${host.keyPath}`);
+	}
+
+	return args;
+}
+
+function unmountPath(path: string): boolean {
+	const fusermount = Bun.which("fusermount") ?? Bun.which("fusermount3");
+	if (fusermount) {
+		const result = Bun.spawnSync([fusermount, "-u", path], {
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "pipe",
+		});
+		if (result.exitCode === 0) return true;
+	}
+
+	const umount = Bun.which("umount");
+	if (!umount) return false;
+	const result = Bun.spawnSync([umount, path], {
+		stdin: "ignore",
+		stdout: "ignore",
+		stderr: "pipe",
+	});
+	return result.exitCode === 0;
+}
+
+export function hasSshfs(): boolean {
+	return Bun.which("sshfs") !== null;
+}
+
+export function isMounted(path: string): boolean {
+	const mountpoint = Bun.which("mountpoint");
+	if (!mountpoint) return false;
+	const result = Bun.spawnSync([mountpoint, "-q", path], {
+		stdin: "ignore",
+		stdout: "ignore",
+		stderr: "ignore",
+	});
+	return result.exitCode === 0;
+}
+
+export async function mountRemote(host: SSHConnectionTarget, remotePath = "/"): Promise<string | undefined> {
+	if (!hasSshfs()) return undefined;
+
+	ensureDir(REMOTE_DIR);
+	ensureDir(CONTROL_DIR);
+
+	const mountPath = getMountPath(host);
+	ensureDir(mountPath);
+
+	if (isMounted(mountPath)) {
+		mountedPaths.add(mountPath);
+		return mountPath;
+	}
+
+	const target = `${buildSshTarget(host)}:${remotePath}`;
+	const result = Bun.spawnSync(["sshfs", ...buildSshfsArgs(host), target, mountPath], {
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	if (result.exitCode !== 0) {
+		const detail = decodeOutput(result.stderr);
+		const suffix = detail ? `: ${detail}` : "";
+		throw new Error(`Failed to mount ${target}${suffix}`);
+	}
+
+	mountedPaths.add(mountPath);
+	return mountPath;
+}
+
+export async function unmountRemote(host: SSHConnectionTarget): Promise<boolean> {
+	const mountPath = getMountPath(host);
+	if (!isMounted(mountPath)) {
+		mountedPaths.delete(mountPath);
+		return false;
+	}
+
+	const success = unmountPath(mountPath);
+	if (success) {
+		mountedPaths.delete(mountPath);
+	}
+
+	return success;
+}
+
+export async function unmountAll(): Promise<void> {
+	for (const mountPath of Array.from(mountedPaths)) {
+		unmountPath(mountPath);
+	}
+	mountedPaths.clear();
+}

package/src/core/ssh-executor.ts

@@ -0,0 +1,5 @@
+/**
+ * Backwards-compatible re-export for SSH execution.
+ */
+
+export { executeSSH, type SSHExecutorOptions, type SSHResult } from "./ssh/ssh-executor";

package/src/core/system-prompt.ts

@@ -2,7 +2,9 @@
  * System prompt construction and project context loading
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import chalk from "chalk";
 import { contextFileCapability } from "../capability/context-file";
 import type { Rule } from "../capability/rule";
@@ -70,6 +72,7 @@ const toolDescriptions: Record<ToolName, string> = {
 	ask: "Ask user for input or clarification",
 	read: "Read file contents",
 	bash: "Execute bash commands (npm, docker, etc.)",
+	ssh: "Execute commands on remote hosts via SSH",
 	edit: "Make surgical edits to files (find exact text and replace)",
 	write: "Create or overwrite files",
 	grep: "Search file contents for patterns (respects .gitignore)",
@@ -126,6 +129,406 @@ function buildPromptFooter(dateTime: string, cwd: string): string {
 	return `Current date and time: ${dateTime}\nCurrent working directory: ${cwd}`;
 }
 
+function execCommand(args: string[]): string | null {
+	const result = Bun.spawnSync(args, { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+	if (result.exitCode !== 0) return null;
+	const output = result.stdout.toString().trim();
+	return output.length > 0 ? output : null;
+}
+
+function execIfExists(command: string, args: string[]): string | null {
+	if (!Bun.which(command)) return null;
+	return execCommand([command, ...args]);
+}
+
+function firstNonEmpty(values: Array<string | undefined | null>): string | null {
+	for (const value of values) {
+		const trimmed = value?.trim();
+		if (trimmed) return trimmed;
+	}
+	return null;
+}
+
+function firstNonEmptyLine(value: string | null): string | null {
+	if (!value) return null;
+	const line = value
+		.split("\n")
+		.map((entry) => entry.trim())
+		.filter(Boolean)[0];
+	return line ?? null;
+}
+
+function parseWmicTable(output: string, header: string): string | null {
+	const lines = output
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(Boolean);
+	const filtered = lines.filter((line) => line.toLowerCase() !== header.toLowerCase());
+	return filtered[0] ?? null;
+}
+
+function parseKeyValueOutput(output: string): Record<string, string> {
+	const result: Record<string, string> = {};
+	for (const line of output.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const [key, ...rest] = trimmed.split("=");
+		if (!key || rest.length === 0) continue;
+		const value = rest.join("=").trim();
+		if (value) result[key.trim()] = value;
+	}
+	return result;
+}
+
+function stripQuotes(value: string): string {
+	return value.replace(/^"|"$/g, "");
+}
+
+function getOsName(): string {
+	switch (process.platform) {
+		case "win32":
+			return "Windows";
+		case "darwin":
+			return "macOS";
+		case "linux":
+			return "Linux";
+		case "freebsd":
+			return "FreeBSD";
+		case "openbsd":
+			return "OpenBSD";
+		case "netbsd":
+			return "NetBSD";
+		case "aix":
+			return "AIX";
+		default:
+			return process.platform || "unknown";
+	}
+}
+
+function getKernelVersion(): string {
+	if (process.platform === "win32") {
+		return execCommand(["cmd", "/c", "ver"]) ?? "unknown";
+	}
+
+	return execCommand(["uname", "-sr"]) ?? "unknown";
+}
+
+function getOsDistro(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["os", "get", "Caption,Version", "/value"]);
+			if (!output) return null;
+			const parsed = parseKeyValueOutput(output);
+			const caption = parsed.Caption;
+			const version = parsed.Version;
+			if (caption && version) return `${caption} ${version}`.trim();
+			return caption ?? version ?? null;
+		}
+		case "darwin": {
+			const name = firstNonEmptyLine(execIfExists("sw_vers", ["-productName"]));
+			const version = firstNonEmptyLine(execIfExists("sw_vers", ["-productVersion"]));
+			if (name && version) return `${name} ${version}`.trim();
+			return name ?? version ?? null;
+		}
+		case "linux": {
+			const lsb = firstNonEmptyLine(execIfExists("lsb_release", ["-ds"]));
+			if (lsb) return stripQuotes(lsb);
+			const osRelease = execIfExists("cat", ["/etc/os-release"]);
+			if (!osRelease) return null;
+			const parsed = parseKeyValueOutput(osRelease);
+			const pretty = parsed.PRETTY_NAME ?? parsed.NAME;
+			const version = parsed.VERSION ?? parsed.VERSION_ID;
+			if (pretty) return stripQuotes(pretty);
+			if (parsed.NAME && version) return `${stripQuotes(parsed.NAME)} ${stripQuotes(version)}`.trim();
+			return parsed.NAME ? stripQuotes(parsed.NAME) : null;
+		}
+		default:
+			return null;
+	}
+}
+
+function getCpuArch(): string {
+	return process.arch || "unknown";
+}
+
+function getCpuModel(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["cpu", "get", "Name"]);
+			return output ? parseWmicTable(output, "Name") : null;
+		}
+		case "darwin": {
+			return firstNonEmptyLine(execIfExists("sysctl", ["-n", "machdep.cpu.brand_string"]));
+		}
+		case "linux": {
+			const lscpu = execIfExists("lscpu", []);
+			if (lscpu) {
+				const match = lscpu
+					.split("\n")
+					.map((line) => line.trim())
+					.find((line) => line.toLowerCase().startsWith("model name:"));
+				if (match) return match.split(":").slice(1).join(":").trim();
+			}
+			const cpuInfo = execIfExists("cat", ["/proc/cpuinfo"]);
+			if (!cpuInfo) return null;
+			for (const line of cpuInfo.split("\n")) {
+				const [key, ...rest] = line.split(":");
+				if (!key || rest.length === 0) continue;
+				const normalized = key.trim().toLowerCase();
+				if (normalized === "model name" || normalized === "hardware" || normalized === "processor") {
+					return rest.join(":").trim();
+				}
+			}
+			return null;
+		}
+		default:
+			return null;
+	}
+}
+
+function getGpuModel(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["path", "win32_VideoController", "get", "name"]);
+			return output ? parseWmicTable(output, "Name") : null;
+		}
+		case "linux": {
+			const output = execIfExists("lspci", []);
+			if (!output) return null;
+			const gpus: Array<{ name: string; priority: number }> = [];
+			for (const line of output.split("\n")) {
+				if (!/(VGA|3D|Display)/i.test(line)) continue;
+				const parts = line.split(":");
+				const name = parts.length > 1 ? parts.slice(1).join(":").trim() : line.trim();
+				const nameLower = name.toLowerCase();
+				// Skip BMC/server management adapters
+				if (/aspeed|matrox g200|mgag200/i.test(name)) continue;
+				// Prioritize discrete GPUs
+				let priority = 0;
+				if (
+					nameLower.includes("nvidia") ||
+					nameLower.includes("geforce") ||
+					nameLower.includes("quadro") ||
+					nameLower.includes("rtx")
+				) {
+					priority = 3;
+				} else if (nameLower.includes("amd") || nameLower.includes("radeon") || nameLower.includes("rx ")) {
+					priority = 3;
+				} else if (nameLower.includes("intel")) {
+					priority = 1;
+				} else {
+					priority = 2;
+				}
+				gpus.push({ name, priority });
+			}
+			if (gpus.length === 0) return null;
+			gpus.sort((a, b) => b.priority - a.priority);
+			return gpus[0].name;
+		}
+		default:
+			return null;
+	}
+}
+
+function getShellName(): string {
+	const shell = firstNonEmpty([process.env.SHELL, process.env.ComSpec]);
+	return shell ?? "unknown";
+}
+
+function getTerminalName(): string {
+	const termProgram = process.env.TERM_PROGRAM;
+	const termProgramVersion = process.env.TERM_PROGRAM_VERSION;
+	if (termProgram) {
+		return termProgramVersion ? `${termProgram} ${termProgramVersion}` : termProgram;
+	}
+
+	if (process.env.WT_SESSION) return "Windows Terminal";
+
+	const term = firstNonEmpty([process.env.TERM, process.env.COLORTERM, process.env.TERMINAL_EMULATOR]);
+	return term ?? "unknown";
+}
+
+function normalizeDesktopValue(value: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) return "unknown";
+	const parts = trimmed
+		.split(":")
+		.map((part) => part.trim())
+		.filter(Boolean);
+	return parts[0] ?? trimmed;
+}
+
+function getDesktopEnvironment(): string {
+	if (process.env.KDE_FULL_SESSION === "true") return "KDE";
+	const raw = firstNonEmpty([
+		process.env.XDG_CURRENT_DESKTOP,
+		process.env.DESKTOP_SESSION,
+		process.env.XDG_SESSION_DESKTOP,
+		process.env.GDMSESSION,
+	]);
+	return raw ? normalizeDesktopValue(raw) : "unknown";
+}
+
+function matchKnownWindowManager(value: string): string | null {
+	const normalized = value.toLowerCase();
+	const candidates = [
+		"sway",
+		"i3",
+		"i3wm",
+		"bspwm",
+		"openbox",
+		"awesome",
+		"herbstluftwm",
+		"fluxbox",
+		"icewm",
+		"dwm",
+		"hyprland",
+		"wayfire",
+		"river",
+		"labwc",
+		"qtile",
+	];
+	for (const candidate of candidates) {
+		if (normalized.includes(candidate)) return candidate;
+	}
+	return null;
+}
+
+function getWindowManager(): string {
+	const explicit = firstNonEmpty([process.env.WINDOWMANAGER]);
+	if (explicit) return explicit;
+
+	const desktop = firstNonEmpty([process.env.XDG_CURRENT_DESKTOP, process.env.DESKTOP_SESSION]);
+	if (desktop) {
+		const matched = matchKnownWindowManager(desktop);
+		if (matched) return matched;
+	}
+
+	return "unknown";
+}
+
+/** Cached system info structure */
+interface SystemInfoCache {
+	os: string;
+	distro: string;
+	kernel: string;
+	arch: string;
+	cpu: string;
+	gpu: string;
+	disk: string;
+}
+
+function getSystemInfoCachePath(): string {
+	return join(homedir(), ".omp", "system_info.json");
+}
+
+function loadSystemInfoCache(): SystemInfoCache | null {
+	try {
+		const cachePath = getSystemInfoCachePath();
+		if (!existsSync(cachePath)) return null;
+		const content = readFileSync(cachePath, "utf-8");
+		return JSON.parse(content) as SystemInfoCache;
+	} catch {
+		return null;
+	}
+}
+
+function saveSystemInfoCache(info: SystemInfoCache): void {
+	try {
+		const cachePath = getSystemInfoCachePath();
+		const dir = join(homedir(), ".omp");
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		writeFileSync(cachePath, JSON.stringify(info, null, "\t"), "utf-8");
+	} catch {
+		// Silently ignore cache write failures
+	}
+}
+
+function collectSystemInfo(): SystemInfoCache {
+	return {
+		os: getOsName(),
+		distro: getOsDistro() ?? "unknown",
+		kernel: getKernelVersion(),
+		arch: getCpuArch(),
+		cpu: getCpuModel() ?? "unknown",
+		gpu: getGpuModel() ?? "unknown",
+		disk: getDiskInfo() ?? "unknown",
+	};
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+	if (bytes < 1024 * 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+	return `${(bytes / (1024 * 1024 * 1024 * 1024)).toFixed(1)}TB`;
+}
+
+function getDiskInfo(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["logicaldisk", "get", "Caption,Size,FreeSpace", "/format:csv"]);
+			if (!output) return null;
+			const lines = output.split("\n").filter((l) => l.trim() && !l.startsWith("Node"));
+			const disks: string[] = [];
+			for (const line of lines) {
+				const parts = line.split(",");
+				if (parts.length < 4) continue;
+				const caption = parts[1]?.trim();
+				const freeSpace = Number.parseInt(parts[2]?.trim() ?? "", 10);
+				const size = Number.parseInt(parts[3]?.trim() ?? "", 10);
+				if (!caption || Number.isNaN(size) || size === 0) continue;
+				const used = size - (Number.isNaN(freeSpace) ? 0 : freeSpace);
+				const pct = Math.round((used / size) * 100);
+				disks.push(`${caption} ${formatBytes(used)}/${formatBytes(size)} (${pct}%)`);
+			}
+			return disks.length > 0 ? disks.join(", ") : null;
+		}
+		case "linux":
+		case "darwin": {
+			const output = execIfExists("df", ["-h", "/"]);
+			if (!output) return null;
+			const lines = output.split("\n");
+			if (lines.length < 2) return null;
+			const parts = lines[1].split(/\s+/);
+			if (parts.length < 5) return null;
+			const size = parts[1];
+			const used = parts[2];
+			const pct = parts[4];
+			return `/ ${used}/${size} (${pct})`;
+		}
+		default:
+			return null;
+	}
+}
+
+function formatEnvironmentInfo(): string {
+	// Load cached system info or collect fresh
+	let sysInfo = loadSystemInfoCache();
+	if (!sysInfo) {
+		sysInfo = collectSystemInfo();
+		saveSystemInfoCache(sysInfo);
+	}
+
+	// Session-specific values (not cached)
+	const items: Array<[string, string]> = [
+		["OS", sysInfo.os],
+		["Distro", sysInfo.distro],
+		["Kernel", sysInfo.kernel],
+		["Arch", sysInfo.arch],
+		["CPU", sysInfo.cpu],
+		["GPU", sysInfo.gpu],
+		["Disk", sysInfo.disk],
+		["Shell", getShellName()],
+		["Terminal", getTerminalName()],
+		["DE", getDesktopEnvironment()],
+		["WM", getWindowManager()],
+	];
+	return items.map(([label, value]) => `- ${label}: ${value}`).join("\n");
+}
+
 /**
  * Generate anti-bash rules section if the agent has both bash and specialized tools.
  * Only include rules for tools that are actually available.
@@ -201,6 +604,24 @@ function generateAntiBashRules(tools: ToolName[]): string | null {
 		);
 	}
 
+	// Add SSH remote filesystem guidance if available
+	const hasSSH = tools.includes("ssh");
+	if (hasSSH) {
+		lines.push("\n### SSH Command Execution");
+		lines.push(
+			"**Critical**: Each SSH host runs a specific shell. **You MUST match commands to the host's shell type**.",
+		);
+		lines.push("Check the host list in the ssh tool description. Shell types:");
+		lines.push("- linux/bash, linux/zsh, macos/bash, macos/zsh: ls, cat, grep, find, ps, df, uname");
+		lines.push("- windows/bash, windows/sh: ls, cat, grep, find (Windows with WSL/Cygwin — Unix commands)");
+		lines.push("- windows/cmd: dir, type, findstr, tasklist, systeminfo");
+		lines.push("- windows/powershell: Get-ChildItem, Get-Content, Select-String, Get-Process");
+		lines.push("");
+		lines.push("### SSH Filesystems");
+		lines.push("Mounted at `~/.omp/remote/<hostname>/` — use read/edit/write tools directly.");
+		lines.push("Windows paths need colon: `~/.omp/remote/host/C:/Users/...` not `C/Users/...`\n");
+	}
+
 	// Add search-first protocol
 	if (hasGrep || hasFind) {
 		lines.push("\n### Search-First Protocol");
@@ -389,6 +810,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 
 	// Generate anti-bash rules (returns null if not applicable)
 	const antiBashSection = generateAntiBashRules(Array.from(tools?.keys() ?? []));
+	const environmentInfo = formatEnvironmentInfo();
 
 	// Build guidelines based on which tools are actually available
 	const guidelinesList: string[] = [];
@@ -446,6 +868,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		toolsList,
 		antiBashSection: antiBashBlock,
 		guidelines,
+		environmentInfo,
 		readmePath,
 		docsPath,
 		examplesPath,