typescript-virtual-container 0.1.0 → 1.0.1

package/.github/workflows/create-pull-request.yml

@@ -3,11 +3,10 @@ name: Auto Create Pull Request
 on:
   push:
     branches:
-      - 'dev'
 
 jobs:
   create-pull-request:
-    if: github.ref == 'refs/heads/dev'
+    if: github.ref != 'refs/heads/main'
     runs-on: ubuntu-latest
     steps:
       - name: Validate pull request token
@@ -26,18 +25,21 @@ jobs:
           script: |
             const owner = context.repo.owner;
             const repo = context.repo.repo;
-            const head = `${owner}:dev`;
+            const sourceBranch = context.ref.startsWith('refs/heads/')
+              ? context.ref.slice('refs/heads/'.length)
+              : context.ref;
+            const head = `${owner}:${sourceBranch}`;
             const base = 'main';
 
-            // Check if there are commits between main and dev
+            // Check if there are commits between main and the current branch
             const { data: comparison } = await github.rest.repos.compareCommits({
               owner,
               repo,
               base: 'main',
-              head: 'dev',
+              head: sourceBranch,
             }).catch(err => {
               if (err.status === 404 && err.message.includes('No commits')) {
-                core.info('No commits between main and dev - skipping PR creation');
+                core.info('No commits between main and ' + sourceBranch + ' - skipping PR creation');
                 return { data: { ahead_by: 0 } };
               }
               throw err;
@@ -64,13 +66,13 @@ jobs:
             const { data: pullRequest } = await github.rest.pulls.create({
               owner,
               repo,
-              head: 'dev',
+              head: sourceBranch,
               base,
-              title: 'chore: auto PR from dev to main',
+              title: `chore: auto PR from ${sourceBranch} to main`,
               body: [
                 'This pull request was created automatically by GitHub Actions.',
                 '',
-                `- source branch: \`dev\``,
+                `- source branch: \`${sourceBranch}\``,
                 `- target branch: \`main\``,
                 `- triggered by commit \`${context.sha}\``,
               ].join('\n'),

package/.github/workflows/test-battery.yml

@@ -3,8 +3,6 @@ name: Test battery
 on:
   pull_request:
     branches:
-      - main
-      - dev
 
 permissions:
   contents: read

package/CHANGELOG.md

@@ -15,6 +15,32 @@ The format is based on Keep a Changelog.
   - CODE_OF_CONDUCT.md
   - GitHub issue and PR templates
 
+## [1.0.1] - 2026-04-14
+
+### Added
+
+- `ls -l` / `ls --long` support with long listing format (permissions, size, updated time).
+- Host-command mirroring for network tools:
+  - `curl` now runs through host `curl` via `child_process`.
+  - `wget` now runs through host `wget` via `child_process`.
+- Temporary host download flow for `wget` using `/tmp` before import into VFS.
+- Terminal line normalization utility for command help and diagnostics rendering.
+
+### Changed
+
+- `curl` behavior is now aligned with the host binary output and exit codes.
+- `curl -o` writes host command output to the virtual filesystem target path.
+- `wget` writes downloaded payloads to VFS after host-side transfer, preserving command semantics.
+- URL fetch helper now accepts host-only inputs by normalizing missing protocol to `http://`.
+- Auto pull-request GitHub workflow now targets any non-`main` branch instead of only `dev`.
+- Auto PR metadata now uses the dynamic source branch name in PR head/title/body.
+- Test workflow trigger scope was generalized by removing hardcoded branch filters.
+
+### Fixed
+
+- Resolved large horizontal spacing artifacts in SSH terminal output by normalizing TTY line endings (`\r\n`) in both interactive shell and exec paths.
+- Reduced excessive whitespace in help output rendering (`curl --help`, `wget --help`) by normalizing tabs and over-padded spacing.
+
 ## [1.0.0] - 2026-04-14
 
 ### Added

package/biome.json

@@ -1,4 +1,11 @@
 {
+    "assist": {
+        "actions": {
+            "source": {
+                "organizeImports": "off"
+            }
+        }
+    },
     "linter": {
         "rules": {
             "suspicious": {
@@ -10,11 +17,5 @@
                 "noNonNullAssertion": "off"
             }
         }
-    },
-    "assist": {
-        "source": {
-            "autoImport": "on",
-            "importModuleSpecifierPreference": "relative"
-        }
     }
 }

package/package.json

@@ -3,7 +3,7 @@
   "description": "In-memory SSH server with virtual filesystem and typed programmatic API",
   "module": "src/index.ts",
   "type": "module",
-  "version": "0.1.0",
+  "version": "1.0.1",
   "license": "MIT",
   "keywords": [
     "ssh",

package/src/SSHMimic/commands/curl.ts

@@ -1,27 +1,152 @@
+import { spawn } from "node:child_process";
 import type { ShellModule } from "../../types/commands";
-import { fetchResource, parseOutputPath, resolvePath } from "./helpers";
+import { normalizeTerminalOutput, resolvePath } from "./helpers";
+
+function parseCurlOutputPath(args: string[]): {
+	outputPath: string | null;
+	inputArgs: string[];
+} {
+	const filtered: string[] = [];
+	let outputPath: string | null = null;
+
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index]!;
+
+		if (arg === "-o" || arg === "--output") {
+			outputPath = args[index + 1] ?? null;
+			index += 1;
+			continue;
+		}
+
+		if (arg.startsWith("-o=")) {
+			outputPath = arg.slice(3);
+			continue;
+		}
+
+		if (arg.startsWith("--output=")) {
+			outputPath = arg.slice("--output=".length);
+			continue;
+		}
+
+		filtered.push(arg);
+	}
+
+	return { outputPath, inputArgs: filtered };
+}
+
+function runHostCurl(args: string[]): Promise<{
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+}> {
+	return new Promise((resolve) => {
+		let childProcess: ReturnType<typeof spawn>;
+
+		try {
+			childProcess = spawn("curl", args, {
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+		} catch (error) {
+			resolve({
+				stdout: "",
+				stderr: `curl: ${error instanceof Error ? error.message : String(error)}`,
+				exitCode: 1,
+			});
+			return;
+		}
+
+		let stdout = "";
+		let stderr = "";
+		const stdoutStream = childProcess.stdout;
+		const stderrStream = childProcess.stderr;
+
+		if (!stdoutStream || !stderrStream) {
+			resolve({
+				stdout: "",
+				stderr: "curl: failed to capture process output",
+				exitCode: 1,
+			});
+			return;
+		}
+
+		stdoutStream.setEncoding("utf8");
+		stderrStream.setEncoding("utf8");
+
+		stdoutStream.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+
+		stderrStream.on("data", (chunk: string) => {
+			stderr += chunk;
+		});
+
+		childProcess.on("error", (error) => {
+			const errorCode =
+				error instanceof Error && "code" in error
+					? String((error as NodeJS.ErrnoException).code ?? "")
+					: "";
+			resolve({
+				stdout: "",
+				stderr: `curl: ${error.message}`,
+				exitCode: errorCode === "ENOENT" ? 127 : 1,
+			});
+		});
+
+		childProcess.on("close", (code) => {
+			resolve({
+				stdout,
+				stderr,
+				exitCode: code ?? 1,
+			});
+		});
+	});
+}
 
 export const curlCommand: ShellModule = {
 	name: "curl",
 	params: ["[-o file] <url>"],
 	run: async ({ vfs, cwd, args }) => {
-		const { outputPath, inputArgs } = parseOutputPath(args);
+		const { outputPath, inputArgs } = parseCurlOutputPath(args);
 		const url = inputArgs[0];
+		const isHelpLike = inputArgs.some(
+			(arg) =>
+				arg === "-h" || arg === "--help" || arg === "-V" || arg === "--version",
+		);
 
 		if (!url) {
 			return { stderr: "curl: missing URL", exitCode: 1 };
 		}
 
-		const result = await fetchResource(url);
-		if (result.status >= 400) {
-			return { stderr: `curl: HTTP ${result.status}`, exitCode: 22 };
+		const passthroughArgs = outputPath ? [...inputArgs, "-o", "-"] : inputArgs;
+		const result = await runHostCurl(passthroughArgs);
+
+		if (result.exitCode !== 0) {
+			return {
+				stderr: normalizeTerminalOutput(
+					result.stderr || `curl: exited with code ${result.exitCode}`,
+				),
+				exitCode: result.exitCode,
+			};
 		}
 
 		if (outputPath) {
-			vfs.writeFile(resolvePath(cwd, outputPath), result.text);
-			return { exitCode: 0 };
+			vfs.writeFile(resolvePath(cwd, outputPath), result.stdout);
+			return {
+				stderr: result.stderr
+					? normalizeTerminalOutput(result.stderr)
+					: undefined,
+				exitCode: 0,
+			};
 		}
 
-		return { stdout: result.text, exitCode: 0 };
+		return {
+			stdout: isHelpLike
+				? normalizeTerminalOutput(result.stdout)
+				: result.stdout,
+			stderr: result.stderr
+				? normalizeTerminalOutput(result.stderr)
+				: undefined,
+			exitCode: 0,
+		};
 	},
 };

package/src/SSHMimic/commands/helpers.ts

@@ -1,6 +1,28 @@
 import * as path from "node:path";
 import type VirtualFileSystem from "../../VirtualFileSystem";
 
+function normalizeFetchUrl(input: string): string {
+	if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input)) {
+		return input;
+	}
+
+	return `http://${input}`;
+}
+
+export function normalizeTerminalOutput(text: string): string {
+	return text
+		.replace(/\r\n/g, "\n")
+		.replace(/\r/g, "\n")
+		.replace(/\t/g, "  ")
+		.split("\n")
+		.map((line) =>
+			line.replace(/^[ \u00A0]{8,}/, "  ").replace(/[ \u00A0]{3,}/g, "  "),
+		)
+		.join("\n")
+		.replace(/\n{3,}/g, "\n\n")
+		.trimEnd();
+}
+
 export function resolvePath(cwd: string, inputPath: string): string {
 	if (!inputPath || inputPath.trim() === "") {
 		return cwd;
@@ -56,7 +78,7 @@ export function stripUrlFilename(url: string): string {
 export async function fetchResource(
 	url: string,
 ): Promise<{ text: string; status: number; contentType: string | null }> {
-	const response = await fetch(url);
+	const response = await fetch(normalizeFetchUrl(url));
 	const contentType = response.headers.get("content-type");
 	return {
 		text: await response.text(),

package/src/SSHMimic/commands/ls.ts

@@ -1,14 +1,48 @@
 import type { ShellModule } from "../../types/commands";
 import { joinListWithType, resolvePath } from "./helpers";
 
+function formatPermissions(mode: number, isDirectory: boolean): string {
+	const fileType = isDirectory ? "d" : "-";
+	const permissionBits = [
+		[0o400, "r"],
+		[0o200, "w"],
+		[0o100, "x"],
+		[0o040, "r"],
+		[0o020, "w"],
+		[0o010, "x"],
+		[0o004, "r"],
+		[0o002, "w"],
+		[0o001, "x"],
+	] as const;
+	const permissions = permissionBits
+		.map(([bit, symbol]) => (mode & bit ? symbol : "-"))
+		.join("");
+
+	return `${fileType}${permissions}`;
+}
+
+function formatDate(date: Date): string {
+	return date.toISOString().replace("T", " ").slice(0, 16);
+}
+
 export const lsCommand: ShellModule = {
 	name: "ls",
 	params: ["[path]"],
 	run: ({ vfs, cwd, args }) => {
+		const longFormat = args.includes("-l") || args.includes("--long");
 		const targetArg = args.find((arg) => !arg.startsWith("-"));
 		const target = resolvePath(cwd, targetArg ?? cwd);
 		const items = vfs.list(target).filter((name) => !name.startsWith("."));
-		const rendered = joinListWithType(target, items, (p) => vfs.stat(p));
+		const rendered = longFormat
+			? items
+					.map((name) => {
+						const childPath = resolvePath(target, name);
+						const stat = vfs.stat(childPath);
+						const size = stat.type === "file" ? stat.size : stat.childrenCount;
+						return `${formatPermissions(stat.mode, stat.type === "directory")} 1 ${size} ${formatDate(stat.updatedAt)} ${name}${stat.type === "directory" ? "/" : ""}`;
+					})
+					.join("\n")
+			: joinListWithType(target, items, (p) => vfs.stat(p));
 		return { stdout: rendered, exitCode: 0 };
 	},
 };

package/src/SSHMimic/commands/wget.ts

@@ -1,33 +1,135 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import type { ShellModule } from "../../types/commands";
 import {
-	fetchResource,
+	normalizeTerminalOutput,
 	parseOutputPath,
 	resolvePath,
 	stripUrlFilename,
 } from "./helpers";
 
+function runHostWget(args: string[]): Promise<{
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+}> {
+	return new Promise((resolve) => {
+		let childProcess: ReturnType<typeof spawn>;
+
+		try {
+			childProcess = spawn("wget", args, {
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+		} catch (error) {
+			resolve({
+				stdout: "",
+				stderr: `wget: ${error instanceof Error ? error.message : String(error)}`,
+				exitCode: 1,
+			});
+			return;
+		}
+
+		let stdout = "";
+		let stderr = "";
+		const stdoutStream = childProcess.stdout;
+		const stderrStream = childProcess.stderr;
+
+		if (!stdoutStream || !stderrStream) {
+			resolve({
+				stdout: "",
+				stderr: "wget: failed to capture process output",
+				exitCode: 1,
+			});
+			return;
+		}
+
+		stdoutStream.setEncoding("utf8");
+		stderrStream.setEncoding("utf8");
+
+		stdoutStream.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+
+		stderrStream.on("data", (chunk: string) => {
+			stderr += chunk;
+		});
+
+		childProcess.on("error", (error) => {
+			const errorCode =
+				error instanceof Error && "code" in error
+					? String((error as NodeJS.ErrnoException).code ?? "")
+					: "";
+			resolve({
+				stdout: "",
+				stderr: `wget: ${error.message}`,
+				exitCode: errorCode === "ENOENT" ? 127 : 1,
+			});
+		});
+
+		childProcess.on("close", (code) => {
+			resolve({
+				stdout,
+				stderr,
+				exitCode: code ?? 1,
+			});
+		});
+	});
+}
+
 export const wgetCommand: ShellModule = {
 	name: "wget",
 	params: ["[url]"],
 	run: async ({ vfs, cwd, args }) => {
 		const { outputPath, inputArgs } = parseOutputPath(args);
 		const url = inputArgs[0];
+		const isHelpLike = inputArgs.some(
+			(arg) =>
+				arg === "-h" || arg === "--help" || arg === "-V" || arg === "--version",
+		);
 
 		if (!url) {
 			return { stderr: "wget: missing URL", exitCode: 1 };
 		}
 
-		const result = await fetchResource(url);
-		if (result.status >= 400) {
-			return { stderr: `wget: HTTP ${result.status}`, exitCode: 8 };
+		if (isHelpLike) {
+			const result = await runHostWget(inputArgs);
+			return {
+				stdout: normalizeTerminalOutput(result.stdout),
+				stderr: result.stderr
+					? normalizeTerminalOutput(result.stderr)
+					: undefined,
+				exitCode: result.exitCode,
+			};
 		}
 
-		const target = resolvePath(cwd, outputPath ?? stripUrlFilename(url));
-		vfs.writeFile(target, result.text);
+		const tempDir = await mkdtemp(join(tmpdir(), "virtual-env-js-wget-"));
+		const tempFile = join(tempDir, "download");
+
+		try {
+			const hostArgs = [...inputArgs, "-O", tempFile];
+			const result = await runHostWget(hostArgs);
 
-		return {
-			stdout: `saved ${target}`,
-			exitCode: 0,
-		};
+			if (result.exitCode !== 0) {
+				return {
+					stderr: normalizeTerminalOutput(
+						result.stderr || `wget: exited with code ${result.exitCode}`,
+					),
+					exitCode: result.exitCode,
+				};
+			}
+
+			const content = await readFile(tempFile, "utf8");
+			const target = resolvePath(cwd, outputPath ?? stripUrlFilename(url));
+			vfs.writeFile(target, content);
+
+			return {
+				stdout: `saved ${target}`,
+				exitCode: 0,
+			};
+		} finally {
+			await rm(tempDir, { recursive: true, force: true });
+		}
 	},
 };

package/src/SSHMimic/exec.ts

@@ -3,6 +3,13 @@ import type VirtualFileSystem from "../VirtualFileSystem";
 import { runCommand } from "./commands";
 import type { VirtualUserManager } from "./users";
 
+function toTtyLines(text: string): string {
+	return text
+		.replace(/\r\n/g, "\n")
+		.replace(/\r/g, "\n")
+		.replace(/\n/g, "\r\n");
+}
+
 export function runExec(
 	stream: ExecStream,
 	cmd: string,
@@ -23,11 +30,11 @@ export function runExec(
 		),
 	).then((result) => {
 		if (result.stdout) {
-			stream.write(`${result.stdout}\n`);
+			stream.write(`${toTtyLines(result.stdout)}\r\n`);
 		}
 
 		if (result.stderr) {
-			stream.stderr.write(`${result.stderr}\n`);
+			stream.stderr.write(`${toTtyLines(result.stderr)}\r\n`);
 		}
 
 		stream.exit(result.exitCode ?? 0);

package/src/SSHMimic/shell.ts

@@ -33,6 +33,13 @@ interface TerminalSize {
 	rows: number;
 }
 
+function toTtyLines(text: string): string {
+	return text
+		.replace(/\r\n/g, "\n")
+		.replace(/\r/g, "\n")
+		.replace(/\n/g, "\r\n");
+}
+
 export function startShell(
 	stream: ShellStream,
 	authUser: string,
@@ -198,11 +205,11 @@ export function startShell(
 		}
 
 		if (result.stdout) {
-			stream.write(`${result.stdout}\r\n`);
+			stream.write(`${toTtyLines(result.stdout)}\r\n`);
 		}
 
 		if (result.stderr) {
-			stream.write(`${result.stderr}\r\n`);
+			stream.write(`${toTtyLines(result.stderr)}\r\n`);
 		}
 
 		if (result.switchUser) {
@@ -671,11 +678,11 @@ export function startShell(
 					}
 
 					if (result.stdout) {
-						stream.write(`${result.stdout}\r\n`);
+						stream.write(`${toTtyLines(result.stdout)}\r\n`);
 					}
 
 					if (result.stderr) {
-						stream.write(`${result.stderr}\r\n`);
+						stream.write(`${toTtyLines(result.stderr)}\r\n`);
 					}
 
 					if (result.closeSession) {

package/src/index.ts

@@ -10,7 +10,7 @@ export type {
 	CommandResult,
 	NanoEditorSession,
 	ShellModule,
-	SudoChallenge
+	SudoChallenge,
 } from "./types/commands";
 export type { ExecStream, ShellStream } from "./types/streams";
 export type {
@@ -25,10 +25,12 @@ export type {
 	VfsSnapshotDirectoryNode,
 	VfsSnapshotFileNode,
 	VfsSnapshotNode,
-	WriteFileOptions
+	WriteFileOptions,
 } from "./types/vfs";
 
 export {
-	SshClient, VirtualFileSystem, SshMimic as VirtualMachine, VirtualUserManager
+	SshClient,
+	VirtualFileSystem,
+	SshMimic as VirtualMachine,
+	VirtualUserManager,
 };
-