@aaarc/handfree-ssh-mcp 1.0.0 → 1.0.2

package/build/tests/integration.test.js

@@ -1,348 +0,0 @@
-#!/usr/bin/env node
-/**
- * handfree-ssh-mcp Integration Tests
- *
- * Tests with REAL SSH connections using servers.yaml config.
- *
- * Usage:
- *   npm run test:integration
- *   npm run test:integration -- --server dev
- *   npm run test:integration -- --server prod
- *
- * Or directly:
- *   node build/tests/integration.test.js
- *   node build/tests/integration.test.js --server dev
- */
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { loadConfigFromYaml } from "../config/config-loader.js";
-import { SSHConnectionManager } from "../services/ssh-connection-manager.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// Colors for terminal output
-const colors = {
-    reset: "\x1b[0m",
-    green: "\x1b[32m",
-    red: "\x1b[31m",
-    yellow: "\x1b[33m",
-    cyan: "\x1b[36m",
-    dim: "\x1b[2m",
-};
-function log(msg, color = "reset") {
-    console.log(`${colors[color]}${msg}${colors.reset}`);
-}
-function success(msg) {
-    log(`  ✅ ${msg}`, "green");
-}
-function fail(msg) {
-    log(`  ❌ ${msg}`, "red");
-}
-function info(msg) {
-    log(`  ℹ️  ${msg}`, "cyan");
-}
-function section(msg) {
-    console.log();
-    log(`━━━ ${msg} ━━━`, "yellow");
-}
-const results = [];
-async function runTest(name, fn) {
-    const start = Date.now();
-    try {
-        await fn();
-        const duration = Date.now() - start;
-        results.push({ name, passed: true, duration });
-        success(`${name} (${duration}ms)`);
-    }
-    catch (error) {
-        const duration = Date.now() - start;
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        results.push({ name, passed: false, error: errorMsg, duration });
-        fail(`${name}: ${errorMsg}`);
-    }
-}
-async function main() {
-    // Parse args
-    const args = process.argv.slice(2);
-    const serverArgIndex = args.indexOf("--server");
-    const targetServer = serverArgIndex !== -1 ? args[serverArgIndex + 1] : null;
-    // Find config file (use root project servers.yaml)
-    const configPath = path.resolve(__dirname, "../../../../servers.yaml");
-    log("\n🧪 handfree-ssh-mcp Integration Tests\n", "cyan");
-    info(`Config: ${configPath}`);
-    if (targetServer) {
-        info(`Target server: ${targetServer}`);
-    }
-    // Load config
-    section("Loading Configuration");
-    let parsedArgs;
-    try {
-        parsedArgs = loadConfigFromYaml(configPath);
-        success(`Loaded ${Object.keys(parsedArgs.configs).length} server(s)`);
-        for (const name of Object.keys(parsedArgs.configs)) {
-            const cfg = parsedArgs.configs[name];
-            info(`  ${name}: ${cfg.username}@${cfg.host}:${cfg.port}`);
-        }
-    }
-    catch (error) {
-        fail(`Failed to load config: ${error}`);
-        process.exit(1);
-    }
-    // Determine which servers to test
-    const serversToTest = targetServer
-        ? [targetServer]
-        : Object.keys(parsedArgs.configs);
-    // Validate server selection
-    for (const server of serversToTest) {
-        if (!parsedArgs.configs[server]) {
-            fail(`Server '${server}' not found in config`);
-            process.exit(1);
-        }
-    }
-    // Initialize SSH manager
-    const sshManager = SSHConnectionManager.getInstance();
-    sshManager.setConfig(parsedArgs.configs, serversToTest);
-    // Run tests for each server
-    for (const serverName of serversToTest) {
-        section(`Testing: ${serverName}`);
-        const config = parsedArgs.configs[serverName];
-        info(`Host: ${config.host}:${config.port}`);
-        info(`User: ${config.username}`);
-        info(`Auth: ${config.password ? "password" : "privateKey"}`);
-        info(`Whitelist patterns: ${config.commandWhitelist?.length || 0}`);
-        // Test: Basic connection
-        await runTest(`[${serverName}] SSH Connection`, async () => {
-            const result = await sshManager.executeCommand("echo 'connection test'", serverName, { timeout: 10000 });
-            if (!result.includes("connection test")) {
-                throw new Error(`Unexpected output: ${result}`);
-            }
-        });
-        // Test: pwd command
-        await runTest(`[${serverName}] pwd command`, async () => {
-            const result = await sshManager.executeCommand("pwd", serverName, { timeout: 5000 });
-            if (!result.startsWith("/")) {
-                throw new Error(`Expected path starting with /, got: ${result}`);
-            }
-        });
-        // Test: ls command
-        await runTest(`[${serverName}] ls command`, async () => {
-            const result = await sshManager.executeCommand("ls -la", serverName, { timeout: 5000 });
-            if (!result.includes("total")) {
-                throw new Error(`Expected 'total' in ls output, got: ${result.substring(0, 100)}`);
-            }
-        });
-        // Test: hostname
-        await runTest(`[${serverName}] hostname command`, async () => {
-            const result = await sshManager.executeCommand("hostname", serverName, { timeout: 5000 });
-            if (result.trim().length === 0) {
-                throw new Error("Empty hostname");
-            }
-        });
-        // Test: whoami
-        await runTest(`[${serverName}] whoami command`, async () => {
-            const result = await sshManager.executeCommand("whoami", serverName, { timeout: 5000 });
-            if (result.trim() !== config.username) {
-                throw new Error(`Expected ${config.username}, got: ${result.trim()}`);
-            }
-        });
-        // Test: date
-        await runTest(`[${serverName}] date command`, async () => {
-            const result = await sshManager.executeCommand("date", serverName, { timeout: 5000 });
-            // Should contain year
-            if (!result.includes("202")) {
-                throw new Error(`Expected date with year, got: ${result}`);
-            }
-        });
-        // Note: Timeout testing is tricky because it depends on network latency
-        // and the exact implementation. We skip it here - the timeout mechanism
-        // is tested at the unit level in command-validation.test.ts
-        // Test: Blocked command (if whitelist is restrictive)
-        if (config.commandWhitelist && config.commandWhitelist.length > 0) {
-            await runTest(`[${serverName}] Whitelist blocking`, async () => {
-                try {
-                    await sshManager.executeCommand("rm -rf /", serverName, { timeout: 5000 });
-                    throw new Error("Dangerous command should have been blocked");
-                }
-                catch (error) {
-                    if (error instanceof Error && error.message.includes("blocked")) {
-                        // Expected - command was blocked
-                        return;
-                    }
-                    if (error instanceof Error && error.message.includes("Dangerous command should have been blocked")) {
-                        throw error;
-                    }
-                    // Some other error blocking it - also acceptable
-                }
-            });
-        }
-        // Test: Docker (if available)
-        await runTest(`[${serverName}] docker ps (if allowed)`, async () => {
-            try {
-                const result = await sshManager.executeCommand("docker ps", serverName, { timeout: 10000 });
-                if (!result.includes("CONTAINER")) {
-                    // Check if docker command not found (expected on some servers)
-                    if (result.includes("command not found") || result.includes("not found") || result.includes("EXIT CODE: 127")) {
-                        info("docker not installed on this server - skipped");
-                        return;
-                    }
-                    throw new Error(`Unexpected docker output: ${result.substring(0, 100)}`);
-                }
-            }
-            catch (error) {
-                if (error instanceof Error && (error.message.includes("blocked") || error.message.includes("whitelist"))) {
-                    info("docker ps not in whitelist - skipped");
-                    return;
-                }
-                // Also handle "command not found" errors thrown as exceptions
-                if (error instanceof Error && (error.message.includes("command not found") || error.message.includes("EXIT CODE: 127"))) {
-                    info("docker not installed on this server - skipped");
-                    return;
-                }
-                throw error;
-            }
-        });
-        // Test: getServerConfig (for show-whitelist tool)
-        await runTest(`[${serverName}] getServerConfig returns config`, async () => {
-            const config = sshManager.getServerConfig(serverName);
-            if (!config) {
-                throw new Error("getServerConfig returned null");
-            }
-            if (config.host !== parsedArgs.configs[serverName].host) {
-                throw new Error("Config host mismatch");
-            }
-            if (!config.commandWhitelist || config.commandWhitelist.length === 0) {
-                info("No custom whitelist - using defaults");
-            }
-            else {
-                info(`Whitelist has ${config.commandWhitelist.length} patterns`);
-            }
-        });
-        // Test: Streaming mode (executeCommandWithProgress)
-        await runTest(`[${serverName}] Streaming mode output`, async () => {
-            const chunks = [];
-            const result = await sshManager.executeCommandWithProgress("echo 'line1' && echo 'line2' && echo 'line3'", serverName, {
-                timeout: 10000,
-                onProgress: (chunk) => chunks.push(chunk),
-            });
-            if (!result.includes("line1") || !result.includes("line2") || !result.includes("line3")) {
-                throw new Error(`Expected 3 lines in output, got: ${result}`);
-            }
-            info(`Received ${chunks.length} progress chunks`);
-        });
-        // Test: list-servers tool (getAllServerInfos)
-        await runTest(`[${serverName}] getAllServerInfos returns data`, async () => {
-            const servers = sshManager.getAllServerInfos();
-            if (!Array.isArray(servers)) {
-                throw new Error("getAllServerInfos did not return an array");
-            }
-            const thisServer = servers.find(s => s.name === serverName);
-            if (!thisServer) {
-                throw new Error(`Server ${serverName} not found in getAllServerInfos`);
-            }
-            if (thisServer.host !== config.host) {
-                throw new Error(`Host mismatch: expected ${config.host}, got ${thisServer.host}`);
-            }
-            info(`Found ${servers.length} server(s) in list`);
-        });
-        // Test: Timeout behavior (short timeout should not hang forever)
-        await runTest(`[${serverName}] Short timeout behavior`, async () => {
-            const start = Date.now();
-            try {
-                // Use a very short timeout (100ms) - command should either complete or timeout quickly
-                await sshManager.executeCommand("sleep 0.05", serverName, { timeout: 500 });
-                // If we get here, the command completed before timeout (which is fine)
-                const elapsed = Date.now() - start;
-                info(`Command completed in ${elapsed}ms`);
-            }
-            catch (error) {
-                // Timeout error is also acceptable - what matters is it didn't hang
-                const elapsed = Date.now() - start;
-                if (elapsed > 5000) {
-                    throw new Error(`Timeout took too long: ${elapsed}ms - should have been ~500ms`);
-                }
-                info(`Command timed out after ${elapsed}ms (expected behavior)`);
-            }
-        });
-        // Test: Upload and Download (if tmp directory is writable)
-        await runTest(`[${serverName}] Upload/Download file transfer`, async () => {
-            const fs = await import("fs");
-            const path = await import("path");
-            // Use a path within the project directory to avoid path traversal detection
-            const projectDir = path.resolve(__dirname, "../..");
-            const testContent = `handfree-ssh-mcp test file - ${Date.now()}`;
-            const localTestFile = path.join(projectDir, `ssh-mcp-test-${Date.now()}.txt`);
-            const remoteTestFile = `/tmp/ssh-mcp-test-${Date.now()}.txt`;
-            const downloadedFile = path.join(projectDir, `ssh-mcp-downloaded-${Date.now()}.txt`);
-            try {
-                // Write local test file
-                fs.writeFileSync(localTestFile, testContent);
-                info(`Created local test file: ${localTestFile}`);
-                // Upload
-                const uploadResult = await sshManager.upload(localTestFile, remoteTestFile, serverName);
-                info(`Upload result: ${uploadResult.substring(0, 50)}...`);
-                // Verify file exists on remote
-                const catResult = await sshManager.executeCommand(`cat ${remoteTestFile}`, serverName, { timeout: 5000 });
-                if (!catResult.includes(testContent)) {
-                    throw new Error(`Uploaded file content mismatch. Expected "${testContent}", got "${catResult}"`);
-                }
-                info("Upload verified - remote file content matches");
-                // Download
-                const downloadResult = await sshManager.download(remoteTestFile, downloadedFile, serverName);
-                info(`Download result: ${downloadResult.substring(0, 50)}...`);
-                // Verify downloaded content
-                const downloadedContent = fs.readFileSync(downloadedFile, "utf-8");
-                if (downloadedContent !== testContent) {
-                    throw new Error(`Downloaded file content mismatch. Expected "${testContent}", got "${downloadedContent}"`);
-                }
-                info("Download verified - local file content matches");
-                // Cleanup remote file
-                try {
-                    await sshManager.executeCommand(`rm ${remoteTestFile}`, serverName, { timeout: 5000 });
-                }
-                catch {
-                    // Ignore cleanup errors (rm might be blocked by whitelist)
-                }
-            }
-            finally {
-                // Cleanup local files
-                try {
-                    if (fs.existsSync(localTestFile))
-                        fs.unlinkSync(localTestFile);
-                    if (fs.existsSync(downloadedFile))
-                        fs.unlinkSync(downloadedFile);
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
-            }
-        });
-    }
-    // Summary
-    section("Test Summary");
-    const passed = results.filter(r => r.passed).length;
-    const failed = results.filter(r => !r.passed).length;
-    const total = results.length;
-    log(`\n  Passed: ${passed}/${total}`, passed === total ? "green" : "yellow");
-    if (failed > 0) {
-        log(`  Failed: ${failed}/${total}`, "red");
-        console.log();
-        for (const r of results.filter(r => !r.passed)) {
-            fail(`${r.name}`);
-            log(`     ${r.error}`, "dim");
-        }
-    }
-    // Cleanup
-    section("Cleanup");
-    try {
-        sshManager.disconnect();
-        success("Disconnected all SSH connections");
-    }
-    catch (error) {
-        fail(`Disconnect error: ${error}`);
-    }
-    console.log();
-    process.exit(failed > 0 ? 1 : 0);
-}
-main().catch((error) => {
-    console.error("Fatal error:", error);
-    process.exit(1);
-});

package/build/tests/output-collector.test.js

@@ -1,70 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { OutputCollector } from "../utils/output-collector.js";
-describe("OutputCollector", () => {
-    it("returns everything when total bytes are below the cap", () => {
-        const c = new OutputCollector(64);
-        c.push("hello");
-        c.push(" world");
-        const snap = c.getSnapshot();
-        assert.strictEqual(snap.tail.toString("utf8"), "hello world");
-        assert.strictEqual(snap.totalBytes, 11);
-        assert.strictEqual(snap.droppedBytes, 0);
-        assert.strictEqual(snap.truncated, false);
-    });
-    it("drops bytes from the head when total exceeds the cap", () => {
-        const c = new OutputCollector(5);
-        c.push("abcdef"); // 6 bytes -> drop 1 from head, keep "bcdef"
-        const snap = c.getSnapshot();
-        assert.strictEqual(snap.tail.toString("utf8"), "bcdef");
-        assert.strictEqual(snap.totalBytes, 6);
-        assert.strictEqual(snap.droppedBytes, 1);
-        assert.strictEqual(snap.truncated, true);
-    });
-    it("keeps only the most recent bytes across multiple pushes", () => {
-        const c = new OutputCollector(4);
-        c.push("aaaa");
-        c.push("bbbb");
-        c.push("cccc"); // tail should be "cccc"
-        const snap = c.getSnapshot();
-        assert.strictEqual(snap.tail.toString("utf8"), "cccc");
-        assert.strictEqual(snap.totalBytes, 12);
-        assert.strictEqual(snap.droppedBytes, 8);
-    });
-    it("handles maxBytes=0 by dropping all input", () => {
-        const c = new OutputCollector(0);
-        c.push("hello");
-        const snap = c.getSnapshot();
-        assert.strictEqual(snap.tail.length, 0);
-        assert.strictEqual(snap.totalBytes, 5);
-        assert.strictEqual(snap.droppedBytes, 5);
-        assert.strictEqual(snap.truncated, true);
-    });
-    it("trims a partial chunk at the head when overshoot < chunk length", () => {
-        const c = new OutputCollector(3);
-        c.push("abcde"); // 5 bytes, overshoot 2 -> keep "cde"
-        const snap = c.getSnapshot();
-        assert.strictEqual(snap.tail.toString("utf8"), "cde");
-        assert.strictEqual(snap.droppedBytes, 2);
-    });
-    it("rejects negative or non-finite maxBytes", () => {
-        assert.throws(() => new OutputCollector(-1), /non-negative/);
-        assert.throws(() => new OutputCollector(Number.NaN), /non-negative/);
-        assert.throws(() => new OutputCollector(Number.POSITIVE_INFINITY), /finite/);
-    });
-    it("ignores empty pushes", () => {
-        const c = new OutputCollector(10);
-        c.push("");
-        c.push(Buffer.alloc(0));
-        const snap = c.getSnapshot();
-        assert.strictEqual(snap.totalBytes, 0);
-        assert.strictEqual(snap.droppedBytes, 0);
-        assert.strictEqual(snap.tail.length, 0);
-    });
-    it("accepts Buffers and strings interchangeably", () => {
-        const c = new OutputCollector(20);
-        c.push(Buffer.from([0x68, 0x69])); // "hi"
-        c.push(" world");
-        assert.strictEqual(c.getSnapshot().tail.toString("utf8"), "hi world");
-    });
-});

package/build/tests/output-log-writer.test.js

@@ -1,205 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { OutputLogWriter } from "../utils/output-log-writer.js";
-describe("OutputLogWriter", () => {
-    let root;
-    beforeEach(() => {
-        root = fs.mkdtempSync(path.join(os.tmpdir(), "handfree-ssh-mcp-logwriter-"));
-    });
-    afterEach(() => {
-        if (fs.existsSync(root)) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    });
-    it("writes a log under <root>/<server>/<user>/<file>.log with META / STDOUT / STDERR / END markers", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "echo hi",
-        });
-        w.appendStdout("hi\n");
-        w.appendStderr("warn\n");
-        w.close({ exitCode: 0, durationMs: 42 });
-        const filePath = w.getPath();
-        assert.ok(filePath.includes(path.join("dev", "alice")), `got ${filePath}`);
-        assert.ok(fs.existsSync(filePath));
-        const content = fs.readFileSync(filePath, "utf8");
-        assert.match(content, /^=== META ===\n/);
-        assert.match(content, /\nserver: dev\n/);
-        assert.match(content, /\nuser: alice\n/);
-        assert.match(content, /\ncommand: echo hi\n/);
-        assert.match(content, /\n=== STDOUT ===\nhi\n\n=== STDERR ===\nwarn\n\n=== END ===\n/);
-        assert.match(content, /\nexitCode: 0\n/);
-        assert.match(content, /\ndurationMs: 42\n/);
-        assert.match(content, /\nstdoutBytes: 3\n/);
-        assert.match(content, /\nstderrBytes: 5\n/);
-    });
-    it("creates server/user directories if they do not exist", () => {
-        const w = new OutputLogWriter({
-            rootDir: path.join(root, "deep", "nested"),
-            serverName: "prod",
-            username: "bob",
-            command: "ls",
-        });
-        w.close({ exitCode: 0, durationMs: 0 });
-        assert.ok(fs.existsSync(path.join(root, "deep", "nested", "prod", "bob")));
-    });
-    it("sanitizes unsafe characters in server/user names", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "../escape",
-            username: "name/with:bad",
-            command: "ls",
-        });
-        w.close({ exitCode: 0, durationMs: 0 });
-        const p = w.getPath();
-        // Must stay inside root and not contain raw separators / colons in the leaf segments.
-        assert.ok(p.startsWith(root), `path escaped root: ${p}`);
-        const rel = path.relative(root, p).split(path.sep);
-        // rel = [serverSeg, userSeg, fileName]
-        assert.strictEqual(rel.length, 3);
-        assert.doesNotMatch(rel[0], /[/:]/);
-        assert.doesNotMatch(rel[1], /[/:]/);
-        assert.notStrictEqual(rel[0], "..");
-    });
-    it("close() is idempotent", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "ls",
-        });
-        w.appendStdout("hello");
-        w.close({ exitCode: 0, durationMs: 1 });
-        const before = fs.readFileSync(w.getPath(), "utf8");
-        // Second close must be a no-op; appending more should not change the file.
-        w.appendStdout(" world");
-        w.close({ exitCode: 99, durationMs: 999 });
-        const after = fs.readFileSync(w.getPath(), "utf8");
-        assert.strictEqual(before, after);
-    });
-    it("reports a null exitCode when the remote was signaled", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "sleep 9999",
-        });
-        w.close({ exitCode: null, durationMs: 0 });
-        const content = fs.readFileSync(w.getPath(), "utf8");
-        assert.match(content, /\nexitCode: null\n/);
-    });
-    it("streams large stdout through a .stdout.part temp file and cleans it up on close", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "yes",
-        });
-        // 2 MiB of stdout in many small writes — should never live fully in RAM.
-        const chunk = Buffer.alloc(64 * 1024, 0x41); // 64 KiB of 'A'
-        for (let i = 0; i < 32; i++) {
-            w.appendStdout(chunk);
-        }
-        const partPath = `${w.getPath()}.stdout.part`;
-        assert.ok(fs.existsSync(partPath), "stdout part file must exist while streaming");
-        const partSize = fs.statSync(partPath).size;
-        assert.strictEqual(partSize, 32 * 64 * 1024);
-        w.close({ exitCode: 0, durationMs: 1 });
-        // Part file must be cleaned up.
-        assert.ok(!fs.existsSync(partPath), "stdout part file must be removed after close");
-        // Final file must contain all the stdout bytes intact.
-        const final = fs.readFileSync(w.getPath());
-        const stdoutStart = final.indexOf("=== STDOUT ===\n");
-        const stderrStart = final.indexOf("\n=== STDERR ===\n");
-        assert.ok(stdoutStart > 0 && stderrStart > stdoutStart);
-        const stdoutBody = final.subarray(stdoutStart + "=== STDOUT ===\n".length, stderrStart);
-        assert.strictEqual(stdoutBody.length, 32 * 64 * 1024);
-        // Spot check: every byte must be 'A'.
-        assert.strictEqual(stdoutBody[0], 0x41);
-        assert.strictEqual(stdoutBody[stdoutBody.length - 1], 0x41);
-        const content = final.toString("utf8");
-        assert.match(content, /\nstdoutBytes: 2097152\n/);
-        assert.match(content, /\nstderrBytes: 0\n/);
-    });
-    it("does not create part files when nothing is appended", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "true",
-        });
-        w.close({ exitCode: 0, durationMs: 0 });
-        assert.ok(fs.existsSync(w.getPath()));
-        assert.ok(!fs.existsSync(`${w.getPath()}.stdout.part`));
-        assert.ok(!fs.existsSync(`${w.getPath()}.stderr.part`));
-        const content = fs.readFileSync(w.getPath(), "utf8");
-        // Empty stdout/stderr sections still produce the markers and zero byte counts.
-        assert.match(content, /\n=== STDOUT ===\n\n=== STDERR ===\n\n=== END ===\n/);
-        assert.match(content, /\nstdoutBytes: 0\n/);
-        assert.match(content, /\nstderrBytes: 0\n/);
-    });
-    it("preserves byte order across interleaved stdout/stderr appends", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "noisy",
-        });
-        // Interleave to make sure we don't accidentally mix streams.
-        w.appendStdout("out-1\n");
-        w.appendStderr("err-1\n");
-        w.appendStdout("out-2\n");
-        w.appendStderr("err-2\n");
-        w.appendStdout("out-3\n");
-        w.close({ exitCode: 0, durationMs: 1 });
-        const content = fs.readFileSync(w.getPath(), "utf8");
-        const stdoutMatch = content.match(/=== STDOUT ===\n([\s\S]*?)\n=== STDERR ===/);
-        const stderrMatch = content.match(/=== STDERR ===\n([\s\S]*?)\n=== END ===/);
-        assert.ok(stdoutMatch && stderrMatch);
-        assert.strictEqual(stdoutMatch[1], "out-1\nout-2\nout-3\n");
-        assert.strictEqual(stderrMatch[1], "err-1\nerr-2\n");
-    });
-    it("ignores appends after close()", () => {
-        const w = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "ls",
-        });
-        w.appendStdout("before\n");
-        w.close({ exitCode: 0, durationMs: 1 });
-        const before = fs.readFileSync(w.getPath(), "utf8");
-        w.appendStdout("after\n");
-        w.appendStderr("after-err\n");
-        const after = fs.readFileSync(w.getPath(), "utf8");
-        assert.strictEqual(before, after);
-    });
-    it("file names sort chronologically and avoid collisions for the same start time", () => {
-        const fixedDate = new Date("2026-05-16T02:15:30.000Z");
-        const a = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "ls",
-            startedAt: fixedDate,
-        });
-        const b = new OutputLogWriter({
-            rootDir: root,
-            serverName: "dev",
-            username: "alice",
-            command: "ls",
-            startedAt: fixedDate,
-        });
-        // Same timestamp prefix, but the random suffix makes them distinct.
-        const baseA = path.basename(a.getPath());
-        const baseB = path.basename(b.getPath());
-        assert.match(baseA, /^20260516T021530Z-\d+-[0-9a-f]{8}\.log$/);
-        assert.match(baseB, /^20260516T021530Z-\d+-[0-9a-f]{8}\.log$/);
-        assert.notStrictEqual(baseA, baseB);
-    });
-});