factorio-test-cli 3.1.2 → 3.2.0

package/config/cli-config.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { testRunnerConfigSchema, registerTestConfigOptions } from "./test-config.js";
 export const DEFAULT_DATA_DIRECTORY = "./factorio-test-data-dir";
-const cliConfigFields = {
+export const fileConfigFields = {
     modPath: {
         schema: z.string().optional(),
         cli: {
@@ -27,8 +27,7 @@ const cliConfigFields = {
         schema: z.string().optional(),
         cli: {
             flags: "-d --data-directory <path>",
-            description: "Factorio data directory, where mods, saves, config etc. will be.",
-            default: DEFAULT_DATA_DIRECTORY,
+            description: `Factorio data directory, where mods, saves, config etc. will be (default: "${DEFAULT_DATA_DIRECTORY}").`,
         },
     },
     save: {
@@ -96,9 +95,17 @@ const cliConfigFields = {
             parseArg: (v) => parseInt(v, 10),
         },
     },
+    outputTimeout: {
+        schema: z.number().min(0).optional(),
+        cli: {
+            flags: "--output-timeout <seconds>",
+            description: "Kill Factorio if no stdout/stderr output received within this many seconds. 0 to disable (default: 15).",
+            parseArg: (v) => parseInt(v, 10),
+        },
+    },
 };
-export const cliConfigSchema = z.object({
-    ...Object.fromEntries(Object.entries(cliConfigFields).map(([k, v]) => [k, v.schema])),
+export const fileConfigSchema = z.object({
+    ...Object.fromEntries(Object.entries(fileConfigFields).map(([k, v]) => [k, v.schema])),
     test: testRunnerConfigSchema.optional(),
 });
 function addOption(command, cli) {
@@ -120,7 +127,7 @@ function addOption(command, cli) {
     }
 }
 export function registerAllCliOptions(command) {
-    const f = cliConfigFields;
+    const f = fileConfigFields;
     command.option("-c --config <path>", "Path to config file (default: factorio-test.json, or 'factorio-test' key in package.json)");
     command.option("-g --graphics", "Launch Factorio with graphics (interactive mode) instead of headless");
     command.option("-w --watch", "Watch for file changes and rerun tests");
@@ -137,6 +144,7 @@ export function registerAllCliOptions(command) {
     addOption(command, f.outputFile.cli);
     command.option("--no-output-file", "Disable writing test results file");
     addOption(command, f.forbidOnly.cli);
+    addOption(command, f.outputTimeout.cli);
     addOption(command, f.watchPatterns.cli);
     addOption(command, f.udpPort.cli);
 }

package/config/index.js

@@ -1,3 +1,3 @@
-export { testRunnerConfigSchema, parseCliTestOptions } from "./test-config.js";
-export { cliConfigSchema, registerAllCliOptions } from "./cli-config.js";
-export { loadConfig, mergeTestConfig, mergeCliConfig, buildTestConfig } from "./loader.js";
+export { parseCliTestOptions, testRunnerConfigSchema } from "./test-config.js";
+export { fileConfigSchema, registerAllCliOptions } from "./cli-config.js";
+export { loadFileConfig, resolveConfig } from "./loader.js";

package/config/loader.js

@@ -1,8 +1,10 @@
 import * as fs from "fs";
 import * as path from "path";
 import { CliError } from "../cli-error.js";
-import { cliConfigSchema, DEFAULT_DATA_DIRECTORY } from "./cli-config.js";
+import { getDefaultOutputPath } from "../test-results.js";
+import { DEFAULT_DATA_DIRECTORY, fileConfigFields, fileConfigSchema } from "./cli-config.js";
 import { parseCliTestOptions } from "./test-config.js";
+const DEFAULT_WATCH_PATTERNS = ["info.json", "**/*.lua"];
 function formatZodError(error, filePath) {
     const issues = error.issues.map((issue) => {
         const pathStr = issue.path.join(".");
@@ -10,7 +12,7 @@ function formatZodError(error, filePath) {
     });
     return `Invalid config in ${filePath}:\n${issues.join("\n")}`;
 }
-export function loadConfig(configPath) {
+export function loadFileConfig(configPath) {
     const paths = configPath
         ? [path.resolve(configPath)]
         : [path.resolve("factorio-test.json"), path.resolve("package.json")];
@@ -21,7 +23,7 @@ export function loadConfig(configPath) {
         const rawConfig = filePath.endsWith("package.json") ? content["factorio-test"] : content;
         if (!rawConfig)
             continue;
-        const result = cliConfigSchema.strict().safeParse(rawConfig);
+        const result = fileConfigSchema.strict().safeParse(rawConfig);
         if (!result.success) {
             throw new CliError(formatZodError(result.error, filePath));
         }
@@ -38,35 +40,41 @@ function resolveConfigPaths(config, configDir) {
         save: config.save ? path.resolve(configDir, config.save) : undefined,
     };
 }
-export function mergeTestConfig(configFile, cliOptions) {
-    return {
-        ...configFile,
-        test_pattern: cliOptions.test_pattern ?? configFile?.test_pattern,
-        tag_whitelist: cliOptions.tag_whitelist ?? configFile?.tag_whitelist,
-        tag_blacklist: cliOptions.tag_blacklist ?? configFile?.tag_blacklist,
-        default_timeout: cliOptions.default_timeout ?? configFile?.default_timeout,
-        game_speed: cliOptions.game_speed ?? configFile?.game_speed,
-        log_passed_tests: cliOptions.log_passed_tests ?? configFile?.log_passed_tests,
-        log_skipped_tests: cliOptions.log_skipped_tests ?? configFile?.log_skipped_tests,
-        reorder_failed_first: cliOptions.reorder_failed_first ?? configFile?.reorder_failed_first,
-        bail: cliOptions.bail ?? configFile?.bail,
-    };
+function mergeTestConfig(fileConfig, cliOptions) {
+    const defined = Object.fromEntries(Object.entries(cliOptions).filter(([, v]) => v !== undefined));
+    return { ...fileConfig, ...defined };
 }
-export function mergeCliConfig(fileConfig, options) {
-    options.modPath ??= fileConfig.modPath;
-    options.modName ??= fileConfig.modName;
-    options.factorioPath ??= fileConfig.factorioPath;
-    options.dataDirectory ??= fileConfig.dataDirectory ?? DEFAULT_DATA_DIRECTORY;
-    options.mods ??= fileConfig.mods;
-    options.factorioArgs ??= fileConfig.factorioArgs;
-    options.verbose ??= fileConfig.verbose;
-    options.quiet ??= fileConfig.quiet;
-    return options;
+function getBaseConfig(fileConfig, cliOptions) {
+    const raw = {};
+    for (const key of Object.keys(fileConfigFields)) {
+        raw[key] = cliOptions[key] ?? fileConfig[key];
+    }
+    return raw;
 }
-export function buildTestConfig(fileConfig, options, patterns) {
-    const cliTestOptions = parseCliTestOptions(options);
-    const testPattern = patterns.length > 0
-        ? patterns.map((p) => `(${p})`).join("|")
-        : (cliTestOptions.test_pattern ?? fileConfig.test?.test_pattern);
-    return mergeTestConfig(fileConfig.test, { ...cliTestOptions, test_pattern: testPattern });
+export function resolveConfig({ cliOptions, patterns }) {
+    const fileConfig = loadFileConfig(cliOptions.config);
+    const baseConfig = getBaseConfig(fileConfig, cliOptions);
+    const testConfig = mergeTestConfig(fileConfig.test, parseCliTestOptions(cliOptions, patterns));
+    return {
+        graphics: cliOptions.graphics,
+        watch: cliOptions.watch,
+        modPath: baseConfig.modPath,
+        modName: baseConfig.modName,
+        factorioPath: baseConfig.factorioPath,
+        dataDirectory: path.resolve(baseConfig.dataDirectory ?? DEFAULT_DATA_DIRECTORY),
+        save: baseConfig.save,
+        mods: baseConfig.mods,
+        factorioArgs: baseConfig.factorioArgs,
+        verbose: baseConfig.verbose,
+        quiet: baseConfig.quiet,
+        outputFile: cliOptions.outputFile === false
+            ? undefined
+            : (baseConfig.outputFile ??
+                getDefaultOutputPath(path.resolve(baseConfig.dataDirectory ?? DEFAULT_DATA_DIRECTORY))),
+        forbidOnly: baseConfig.forbidOnly ?? true,
+        watchPatterns: baseConfig.watchPatterns ?? DEFAULT_WATCH_PATTERNS,
+        udpPort: baseConfig.udpPort ?? 14434,
+        outputTimeout: baseConfig.outputTimeout ?? 15,
+        testConfig,
+    };
 }

package/config/test-config.js

@@ -88,7 +88,7 @@ export function registerTestConfigOptions(command) {
 function snakeToCamel(str) {
     return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 }
-export function parseCliTestOptions(opts) {
+export function parseCliTestOptions(opts, patterns) {
     const result = {};
     for (const snake of Object.keys(testConfigFields)) {
         const camel = snakeToCamel(snake);
@@ -100,5 +100,8 @@ export function parseCliTestOptions(opts) {
             result[snake] = value;
         }
     }
+    if (patterns.length > 0) {
+        result.test_pattern = patterns.map((p) => `(${p})`).join("|");
+    }
     return result;
 }

package/config.test.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach, assertType } from "vitest";
 import * as fs from "fs";
 import * as path from "path";
-import { loadConfig, mergeTestConfig, buildTestConfig } from "./config/index.js";
+import { loadFileConfig, resolveConfig } from "./config/index.js";
 const testDir = path.join(import.meta.dirname, "__test_fixtures__");
 describe("loadConfig", () => {
     beforeEach(() => {
@@ -11,7 +11,7 @@ describe("loadConfig", () => {
         fs.rmSync(testDir, { recursive: true, force: true });
     });
     it("returns empty object when no config exists", () => {
-        expect(loadConfig(path.join(testDir, "nonexistent.json"))).toEqual({});
+        expect(loadFileConfig(path.join(testDir, "nonexistent.json"))).toEqual({});
     });
     it("loads factorio-test.json with snake_case test config", () => {
         const configPath = path.join(testDir, "factorio-test.json");
@@ -19,7 +19,7 @@ describe("loadConfig", () => {
             modPath: "./test",
             test: { game_speed: 100 },
         }));
-        expect(loadConfig(configPath)).toMatchObject({
+        expect(loadFileConfig(configPath)).toMatchObject({
             modPath: path.join(testDir, "test"),
             test: { game_speed: 100 },
         });
@@ -27,27 +27,27 @@ describe("loadConfig", () => {
     it("throws on invalid keys", () => {
         const configPath = path.join(testDir, "bad.json");
         fs.writeFileSync(configPath, JSON.stringify({ test: { invalid_key: true } }));
-        expect(() => loadConfig(configPath)).toThrow();
+        expect(() => loadFileConfig(configPath)).toThrow();
     });
     it("error message includes file path for invalid top-level key", () => {
         const configPath = path.join(testDir, "bad-toplevel.json");
         fs.writeFileSync(configPath, JSON.stringify({ unknownKey: true }));
-        expect(() => loadConfig(configPath)).toThrow(configPath);
+        expect(() => loadFileConfig(configPath)).toThrow(configPath);
     });
     it("error message includes field name for invalid top-level key", () => {
         const configPath = path.join(testDir, "bad-toplevel.json");
         fs.writeFileSync(configPath, JSON.stringify({ unknownKey: true }));
-        expect(() => loadConfig(configPath)).toThrow(/unknownKey/);
+        expect(() => loadFileConfig(configPath)).toThrow(/unknownKey/);
     });
     it("error message includes field path for invalid nested key", () => {
         const configPath = path.join(testDir, "bad-nested.json");
         fs.writeFileSync(configPath, JSON.stringify({ test: { badNestedKey: true } }));
-        expect(() => loadConfig(configPath)).toThrow(/test/);
+        expect(() => loadFileConfig(configPath)).toThrow(/test/);
     });
     it("error message includes field name for type mismatch", () => {
         const configPath = path.join(testDir, "bad-type.json");
         fs.writeFileSync(configPath, JSON.stringify({ test: { game_speed: "fast" } }));
-        expect(() => loadConfig(configPath)).toThrow(/game_speed/);
+        expect(() => loadFileConfig(configPath)).toThrow(/game_speed/);
     });
 });
 describe("TestRunnerConfig type compatibility", () => {
@@ -55,40 +55,94 @@ describe("TestRunnerConfig type compatibility", () => {
         assertType({});
     });
 });
-describe("mergeTestConfig", () => {
-    it("CLI options override config file", () => {
-        const result = mergeTestConfig({ game_speed: 100 }, { game_speed: 200 });
-        expect(result.game_speed).toBe(200);
-    });
-    it("CLI test pattern overrides config file", () => {
-        const result = mergeTestConfig({ test_pattern: "foo" }, { test_pattern: "bar" });
-        expect(result.test_pattern).toBe("bar");
+describe("resolveConfig", () => {
+    beforeEach(() => {
+        fs.mkdirSync(testDir, { recursive: true });
     });
-    it("preserves config file values when CLI undefined", () => {
-        const result = mergeTestConfig({ game_speed: 100, log_passed_tests: true }, {});
-        expect(result.game_speed).toBe(100);
-        expect(result.log_passed_tests).toBe(true);
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
     });
-});
-describe("buildTestConfig test pattern priority", () => {
-    const baseOptions = { dataDirectory: "." };
-    it("positional patterns override CLI option and config file", () => {
-        const result = buildTestConfig({ test: { test_pattern: "config" } }, { ...baseOptions, testPattern: "cli" }, [
-            "pos1",
-            "pos2",
-        ]);
-        expect(result.test_pattern).toBe("(pos1)|(pos2)");
-    });
-    it("CLI option overrides config file when no positional patterns", () => {
-        const result = buildTestConfig({ test: { test_pattern: "config" } }, { ...baseOptions, testPattern: "cli" }, []);
-        expect(result.test_pattern).toBe("cli");
-    });
-    it("uses config file when no CLI option or positional patterns", () => {
-        const result = buildTestConfig({ test: { test_pattern: "config" } }, baseOptions, []);
-        expect(result.test_pattern).toBe("config");
-    });
-    it("undefined when no patterns specified anywhere", () => {
-        const result = buildTestConfig({}, baseOptions, []);
-        expect(result.test_pattern).toBeUndefined();
+    function writeConfig(config) {
+        const configPath = path.join(testDir, "factorio-test.json");
+        fs.writeFileSync(configPath, JSON.stringify(config));
+        return configPath;
+    }
+    it("CLI options override file config", () => {
+        const configPath = writeConfig({ verbose: true, forbidOnly: false });
+        const result = resolveConfig({
+            cliOptions: { config: configPath, verbose: false, forbidOnly: true },
+            patterns: [],
+        });
+        expect(result.verbose).toBe(false);
+        expect(result.forbidOnly).toBe(true);
+    });
+    it("applies defaults when neither CLI nor file provides value", () => {
+        const configPath = writeConfig({});
+        const result = resolveConfig({ cliOptions: { config: configPath }, patterns: [] });
+        expect(result.forbidOnly).toBe(true);
+        expect(result.udpPort).toBe(14434);
+        expect(result.outputTimeout).toBe(15);
+        expect(result.watchPatterns).toEqual(["info.json", "**/*.lua"]);
+    });
+    it("outputFile: false disables output", () => {
+        const configPath = writeConfig({ outputFile: "results.json" });
+        const result = resolveConfig({
+            cliOptions: { config: configPath, outputFile: false },
+            patterns: [],
+        });
+        expect(result.outputFile).toBeUndefined();
+    });
+    it("computes default outputFile from dataDirectory", () => {
+        const configPath = writeConfig({});
+        const result = resolveConfig({ cliOptions: { config: configPath }, patterns: [] });
+        expect(result.outputFile).toMatch(/test-results\.json$/);
+    });
+    it("file config fills in missing CLI values", () => {
+        const configPath = writeConfig({ udpPort: 9999, outputTimeout: 30 });
+        const result = resolveConfig({ cliOptions: { config: configPath }, patterns: [] });
+        expect(result.udpPort).toBe(9999);
+        expect(result.outputTimeout).toBe(30);
+    });
+    describe("test config merge", () => {
+        it("positional patterns override CLI option and config file", () => {
+            const configPath = writeConfig({ test: { test_pattern: "config" } });
+            const result = resolveConfig({
+                cliOptions: { config: configPath, testPattern: "cli" },
+                patterns: ["pos1", "pos2"],
+            });
+            expect(result.testConfig.test_pattern).toBe("(pos1)|(pos2)");
+        });
+        it("CLI option overrides config file when no positional patterns", () => {
+            const configPath = writeConfig({ test: { test_pattern: "config" } });
+            const result = resolveConfig({
+                cliOptions: { config: configPath, testPattern: "cli" },
+                patterns: [],
+            });
+            expect(result.testConfig.test_pattern).toBe("cli");
+        });
+        it("uses config file when no CLI option or positional patterns", () => {
+            const configPath = writeConfig({ test: { test_pattern: "config" } });
+            const result = resolveConfig({ cliOptions: { config: configPath }, patterns: [] });
+            expect(result.testConfig.test_pattern).toBe("config");
+        });
+        it("undefined when no patterns specified anywhere", () => {
+            const configPath = writeConfig({});
+            const result = resolveConfig({ cliOptions: { config: configPath }, patterns: [] });
+            expect(result.testConfig.test_pattern).toBeUndefined();
+        });
+        it("CLI test options override file test config", () => {
+            const configPath = writeConfig({ test: { game_speed: 100 } });
+            const result = resolveConfig({
+                cliOptions: { config: configPath, gameSpeed: 200 },
+                patterns: [],
+            });
+            expect(result.testConfig.game_speed).toBe(200);
+        });
+        it("preserves file test config when CLI undefined", () => {
+            const configPath = writeConfig({ test: { game_speed: 100, log_passed_tests: true } });
+            const result = resolveConfig({ cliOptions: { config: configPath }, patterns: [] });
+            expect(result.testConfig.game_speed).toBe(100);
+            expect(result.testConfig.log_passed_tests).toBe(true);
+        });
     });
 });

package/factorio-process.js

@@ -86,15 +86,20 @@ export function getHeadlessSavePath(overridePath) {
     return path.join(__dirname, "headless-save.zip");
 }
 export function parseResultMessage(message) {
-    if (message.endsWith(":focused")) {
-        return {
-            status: message.slice(0, -":focused".length),
-            hasFocusedTests: true,
-        };
+    let remaining = message;
+    let status;
+    const hasFocused = remaining.endsWith(":focused");
+    if (hasFocused)
+        remaining = remaining.slice(0, -":focused".length);
+    if (remaining.startsWith("bailed:")) {
+        status = "bailed";
+    }
+    else {
+        status = remaining;
     }
     return {
-        status: message,
-        hasFocusedTests: false,
+        status: status,
+        hasFocusedTests: hasFocused,
     };
 }
 function createOutputComponents(options) {
@@ -150,6 +155,7 @@ export async function runFactorioTestsHeadless(factorioPath, dataDir, savePath,
     let testRunStarted = false;
     let startupTimedOut = false;
     let wasCancelled = false;
+    let outputTimedOut = false;
     handler.on("event", (event) => {
         if (event.type === "testRunStarted") {
             testRunStarted = true;
@@ -162,20 +168,46 @@ export async function runFactorioTestsHeadless(factorioPath, dataDir, savePath,
             factorioProcess.kill();
         }
     }, 10_000);
+    const outputTimeout = options.outputTimeout;
+    let outputWatchdog;
+    function resetOutputWatchdog() {
+        if (!outputTimeout)
+            return;
+        clearTimeout(outputWatchdog);
+        outputWatchdog = setTimeout(() => {
+            outputTimedOut = true;
+            factorioProcess.kill();
+        }, outputTimeout * 1000);
+    }
+    if (outputTimeout) {
+        resetOutputWatchdog();
+    }
     const abortHandler = () => {
         wasCancelled = true;
         factorioProcess.kill();
     };
     options.signal?.addEventListener("abort", abortHandler);
-    new BufferLineSplitter(factorioProcess.stdout).on("line", (line) => handler.handleLine(line));
-    new BufferLineSplitter(factorioProcess.stderr).on("line", (line) => handler.handleLine(line));
+    const stdoutSplitter = new BufferLineSplitter(factorioProcess.stdout);
+    const stderrSplitter = new BufferLineSplitter(factorioProcess.stderr);
+    stdoutSplitter.on("line", (line) => {
+        resetOutputWatchdog();
+        handler.handleLine(line);
+    });
+    stderrSplitter.on("line", (line) => {
+        resetOutputWatchdog();
+        handler.handleLine(line);
+    });
     await new Promise((resolve, reject) => {
         factorioProcess.on("exit", (code, signal) => {
             clearTimeout(startupTimeout);
+            clearTimeout(outputWatchdog);
             options.signal?.removeEventListener("abort", abortHandler);
             if (wasCancelled) {
                 resolve();
             }
+            else if (outputTimedOut) {
+                reject(new CliError(`Factorio process stuck: no output received for ${outputTimeout} seconds`));
+            }
             else if (startupTimedOut) {
                 reject(new CliError("Factorio unresponsive: no test run started within 10 seconds"));
             }

package/factorio-process.test.js

@@ -16,6 +16,8 @@ describe("parseResultMessage", () => {
         ["passed:focused", { status: "passed", hasFocusedTests: true }],
         ["failed:focused", { status: "failed", hasFocusedTests: true }],
         ["todo:focused", { status: "todo", hasFocusedTests: true }],
+        ["bailed:failed", { status: "bailed", hasFocusedTests: false }],
+        ["bailed:failed:focused", { status: "bailed", hasFocusedTests: true }],
     ])("parses %s", (input, expected) => {
         expect(parseResultMessage(input)).toEqual(expected);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-test-cli",
-  "version": "3.1.2",
+  "version": "3.2.0",
   "description": "A CLI to run FactorioTest.",
   "license": "MIT",
   "repository": {

package/run.js

@@ -4,13 +4,14 @@ import * as dgram from "dgram";
 import * as fsp from "fs/promises";
 import * as path from "path";
 import { CliError } from "./cli-error.js";
-import { buildTestConfig, loadConfig, mergeCliConfig, registerAllCliOptions, } from "./config/index.js";
+import { registerAllCliOptions, resolveConfig } from "./config/index.js";
 import { autoDetectFactorioPath } from "./factorio-process.js";
 import { getHeadlessSavePath, runFactorioTestsGraphics, runFactorioTestsHeadless, } from "./factorio-process.js";
 import { watchDirectory, watchFile } from "./file-watcher.js";
 import { configureModToTest, ensureConfigIni, installFactorioTest, installModDependencies, installMods, parseModRequirement, resetAutorunSettings, resolveModWatchTarget, setSettingsForAutorun, } from "./mod-setup.js";
 import { runScript, setVerbose } from "./process-utils.js";
-import { getDefaultOutputPath, readPreviousFailedTests, writeResultsFile } from "./test-results.js";
+import { OutputFormatter } from "./test-output.js";
+import { readPreviousFailedTests, writeResultsFile } from "./test-results.js";
 const thisCommand = program
     .command("run")
     .summary("Runs tests with Factorio test.")
@@ -37,24 +38,23 @@ Examples:
     .argument("[filter...]", "Lua patterns to filter tests (OR logic)");
 registerAllCliOptions(thisCommand);
 thisCommand.action((patterns, options) => runTests(patterns, options));
-async function setupTestRun(patterns, options) {
-    const fileConfig = loadConfig(options.config);
-    mergeCliConfig(fileConfig, options);
-    setVerbose(!!options.verbose);
-    if (options.modPath !== undefined && options.modName !== undefined) {
+async function setupTestRun(patterns, cliOptions) {
+    const config = resolveConfig({ cliOptions, patterns });
+    setVerbose(!!config.verbose);
+    if (config.modPath !== undefined && config.modName !== undefined) {
         throw new CliError("Only one of --mod-path or --mod-name can be specified.");
     }
-    if (options.modPath === undefined && options.modName === undefined) {
+    if (config.modPath === undefined && config.modName === undefined) {
         throw new CliError("One of --mod-path or --mod-name must be specified.");
     }
-    const factorioPath = options.factorioPath ?? autoDetectFactorioPath();
-    const dataDir = path.resolve(options.dataDirectory);
+    const factorioPath = config.factorioPath ?? autoDetectFactorioPath();
+    const dataDir = config.dataDirectory;
     const modsDir = path.join(dataDir, "mods");
     await fsp.mkdir(modsDir, { recursive: true });
-    const modToTest = await configureModToTest(modsDir, options.modPath, options.modName, options.verbose);
-    const modDependencies = options.modPath ? await installModDependencies(modsDir, path.resolve(options.modPath)) : [];
+    const modToTest = await configureModToTest(modsDir, config.modPath, config.modName, config.verbose);
+    const modDependencies = config.modPath ? await installModDependencies(modsDir, path.resolve(config.modPath)) : [];
     await installFactorioTest(modsDir);
-    const configModRequirements = options.mods
+    const configModRequirements = config.mods
         ?.filter((m) => !m.match(/^\S+=(?:true|false)$/))
         .map(parseModRequirement)
         .filter((r) => r != null) ?? [];
@@ -65,106 +65,88 @@ async function setupTestRun(patterns, options) {
         "factorio-test=true",
         `${modToTest}=true`,
         ...modDependencies.map((m) => `${m}=true`),
-        ...(options.mods?.map((m) => (m.match(/^\S+=(?:true|false)$/) ? m : `${m.split(/\s/)[0]}=true`)) ?? []),
+        ...(config.mods?.map((m) => (m.match(/^\S+=(?:true|false)$/) ? m : `${m.split(/\s/)[0]}=true`)) ?? []),
     ];
-    if (options.verbose)
+    if (config.verbose)
         console.log("Adjusting mods");
     await runScript("fmtk", "mods", "adjust", "--modsPath", modsDir, "--disableExtra", ...enableModsOptions);
     await ensureConfigIni(dataDir);
-    const mode = options.graphics ? "graphics" : "headless";
-    const savePath = getHeadlessSavePath(options.save ?? fileConfig.save);
-    const outputPath = options.outputFile === false
-        ? undefined
-        : (options.outputFile ?? fileConfig.outputFile ?? getDefaultOutputPath(dataDir));
-    const testConfig = buildTestConfig(fileConfig, options, patterns);
-    const udpPort = options.watch && options.graphics ? (options.udpPort ?? fileConfig.udpPort ?? 14434) : undefined;
-    const factorioArgs = [...(options.factorioArgs ?? [])];
-    if (udpPort !== undefined) {
-        factorioArgs.push(`--enable-lua-udp=${udpPort}`);
+    const mode = config.graphics ? "graphics" : "headless";
+    const savePath = getHeadlessSavePath(config.save);
+    const factorioArgs = [...(config.factorioArgs ?? [])];
+    if (config.watch && config.graphics) {
+        factorioArgs.push(`--enable-lua-udp=${config.udpPort}`);
     }
-    return {
-        factorioPath,
-        dataDir,
-        modsDir,
-        modToTest,
-        mode,
-        savePath,
-        outputPath,
-        factorioArgs,
-        testConfig,
-        options,
-        fileConfig,
-        udpPort,
-    };
+    return { config, factorioPath, dataDir, modsDir, modToTest, mode, savePath, factorioArgs };
 }
 async function executeTestRun(ctx, execOptions) {
-    const { factorioPath, dataDir, modsDir, modToTest, mode, savePath, outputPath, factorioArgs, testConfig, options } = ctx;
+    const { config, factorioPath, dataDir, modsDir, modToTest, mode, savePath, factorioArgs } = ctx;
     const { signal, skipResetAutorun, resolveOnResult } = execOptions ?? {};
-    const reorderEnabled = options.reorderFailedFirst ?? ctx.fileConfig.test?.reorder_failed_first ?? true;
-    const lastFailedTests = reorderEnabled && outputPath ? await readPreviousFailedTests(outputPath) : [];
+    const reorderEnabled = config.testConfig.reorder_failed_first ?? true;
+    const lastFailedTests = reorderEnabled && config.outputFile ? await readPreviousFailedTests(config.outputFile) : [];
     await setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest, mode, {
-        verbose: options.verbose,
+        verbose: config.verbose,
         lastFailedTests,
     });
-    if (Object.keys(testConfig).length > 0) {
-        await runScript("fmtk", "settings", "set", "runtime-global", "factorio-test-config", JSON.stringify(testConfig), "--modsPath", modsDir);
+    if (Object.keys(config.testConfig).length > 0) {
+        await runScript("fmtk", "settings", "set", "runtime-global", "factorio-test-config", JSON.stringify(config.testConfig), "--modsPath", modsDir);
     }
     let result;
     try {
         result =
             mode === "headless"
                 ? await runFactorioTestsHeadless(factorioPath, dataDir, savePath, factorioArgs, {
-                    verbose: options.verbose,
-                    quiet: options.quiet,
+                    verbose: config.verbose,
+                    quiet: config.quiet,
                     signal,
+                    outputTimeout: config.outputTimeout,
                 })
                 : await runFactorioTestsGraphics(factorioPath, dataDir, savePath, factorioArgs, {
-                    verbose: options.verbose,
-                    quiet: options.quiet,
+                    verbose: config.verbose,
+                    quiet: config.quiet,
                     resolveOnResult,
                 });
     }
     finally {
         if (!skipResetAutorun) {
-            await resetAutorunSettings(modsDir, options.verbose);
+            await resetAutorunSettings(modsDir, config.verbose);
             await runScript("fmtk", "settings", "set", "runtime-global", "factorio-test-config", "{}", "--modsPath", modsDir);
         }
     }
     if (result.status === "cancelled") {
         return { exitCode: 0, status: "cancelled" };
     }
-    if (outputPath && result.data) {
-        await writeResultsFile(outputPath, modToTest, result.data);
-        if (options.verbose)
-            console.log(`Results written to ${outputPath}`);
+    if (config.outputFile && result.data) {
+        await writeResultsFile(config.outputFile, modToTest, result.data);
+        if (config.verbose)
+            console.log(`Results written to ${config.outputFile}`);
     }
     let resultStatus = result.status;
     if (resultStatus === "bailed") {
-        console.log(chalk.yellow(`Bailed out after ${testConfig.bail} failure(s)`));
+        console.log(chalk.yellow(`Bailed out after ${config.testConfig.bail} failure(s)`));
         resultStatus = "failed";
     }
-    const color = resultStatus == "passed" ? chalk.greenBright : resultStatus == "todo" ? chalk.yellowBright : chalk.redBright;
-    console.log("Test run result:", color(resultStatus));
-    const forbidOnly = options.forbidOnly ?? ctx.fileConfig.forbidOnly ?? true;
-    if (result.hasFocusedTests && forbidOnly) {
+    if (result.data) {
+        const formatter = new OutputFormatter({ quiet: config.quiet });
+        formatter.formatSummary(result.data);
+    }
+    if (result.hasFocusedTests && config.forbidOnly) {
         console.log(chalk.redBright("Error: .only tests are present but --forbid-only is enabled"));
         return { exitCode: 1, status: resultStatus };
     }
     return { exitCode: resultStatus === "passed" ? 0 : 1, status: resultStatus };
 }
-const DEFAULT_WATCH_PATTERNS = ["info.json", "**/*.lua"];
 async function runGraphicsWatchMode(ctx) {
-    const watchPatterns = ctx.options.watchPatterns ?? ctx.fileConfig.watchPatterns ?? DEFAULT_WATCH_PATTERNS;
-    const target = await resolveModWatchTarget(ctx.modsDir, ctx.options.modPath, ctx.options.modName);
-    console.log(chalk.gray(`Watching ${target.path} for patterns: ${watchPatterns.join(", ")}`));
+    const target = await resolveModWatchTarget(ctx.modsDir, ctx.config.modPath, ctx.config.modName);
+    console.log(chalk.gray(`Watching ${target.path} for patterns: ${ctx.config.watchPatterns.join(", ")}`));
     await executeTestRun(ctx, { skipResetAutorun: true, resolveOnResult: true });
     const udpClient = dgram.createSocket("udp4");
     const onFileChange = () => {
         console.log(chalk.cyan("File change detected, triggering rerun..."));
-        udpClient.send("rerun", ctx.udpPort, "127.0.0.1");
+        udpClient.send("rerun", ctx.config.udpPort, "127.0.0.1");
     };
     const watcher = target.type === "directory"
-        ? watchDirectory(target.path, onFileChange, { patterns: watchPatterns })
+        ? watchDirectory(target.path, onFileChange, { patterns: ctx.config.watchPatterns })
         : watchFile(target.path, onFileChange);
     process.on("SIGINT", () => {
         watcher.close();
@@ -174,8 +156,7 @@ async function runGraphicsWatchMode(ctx) {
     return new Promise(() => { });
 }
 async function runHeadlessWatchMode(ctx) {
-    const watchPatterns = ctx.options.watchPatterns ?? ctx.fileConfig.watchPatterns ?? DEFAULT_WATCH_PATTERNS;
-    const target = await resolveModWatchTarget(ctx.modsDir, ctx.options.modPath, ctx.options.modName);
+    const target = await resolveModWatchTarget(ctx.modsDir, ctx.config.modPath, ctx.config.modName);
     let abortController;
     const runOnce = async () => {
         abortController?.abort();
@@ -202,7 +183,7 @@ async function runHeadlessWatchMode(ctx) {
         runOnce();
     };
     const watcher = target.type === "directory"
-        ? watchDirectory(target.path, onFileChange, { patterns: watchPatterns })
+        ? watchDirectory(target.path, onFileChange, { patterns: ctx.config.watchPatterns })
         : watchFile(target.path, onFileChange);
     process.on("SIGINT", () => {
         watcher.close();
@@ -210,12 +191,12 @@ async function runHeadlessWatchMode(ctx) {
     });
     return new Promise(() => { });
 }
-async function runTests(patterns, options) {
-    const ctx = await setupTestRun(patterns, options);
-    if (options.watch && options.graphics) {
+async function runTests(patterns, cliOptions) {
+    const ctx = await setupTestRun(patterns, cliOptions);
+    if (ctx.config.watch && ctx.config.graphics) {
         await runGraphicsWatchMode(ctx);
     }
-    else if (options.watch) {
+    else if (ctx.config.watch) {
         await runHeadlessWatchMode(ctx);
     }
     else {

package/schema.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { testRunnerConfigSchema, cliConfigSchema, parseCliTestOptions } from "./config/index.js";
+import { testRunnerConfigSchema, fileConfigSchema, parseCliTestOptions } from "./config/index.js";
 describe("testRunnerConfigSchema", () => {
     it("parses valid config with snake_case keys", () => {
         const config = {
@@ -19,23 +19,23 @@ describe("testRunnerConfigSchema", () => {
         expect(() => testRunnerConfigSchema.parse({ unknown_key: true })).toThrow();
     });
 });
-describe("cliConfigSchema", () => {
+describe("fileConfigSchema", () => {
     it("parses config file with snake_case test keys", () => {
         const config = {
             modPath: "./my-mod",
             test: { game_speed: 50, log_passed_tests: true },
         };
-        expect(cliConfigSchema.parse(config)).toEqual(config);
+        expect(fileConfigSchema.parse(config)).toEqual(config);
     });
     it("rejects unknown keys in strict mode", () => {
-        expect(() => cliConfigSchema.strict().parse({ unknownKey: true })).toThrow();
+        expect(() => fileConfigSchema.strict().parse({ unknownKey: true })).toThrow();
     });
     it("accepts forbidOnly boolean", () => {
         const config = { forbidOnly: false };
-        expect(cliConfigSchema.parse(config)).toEqual(config);
+        expect(fileConfigSchema.parse(config)).toEqual(config);
     });
     it("defaults forbidOnly to undefined", () => {
-        expect(cliConfigSchema.parse({}).forbidOnly).toBeUndefined();
+        expect(fileConfigSchema.parse({}).forbidOnly).toBeUndefined();
     });
 });
 describe("parseCliTestOptions", () => {
@@ -45,23 +45,29 @@ describe("parseCliTestOptions", () => {
             gameSpeed: 100,
             logPassedTests: true,
         };
-        expect(parseCliTestOptions(commanderOpts)).toEqual({
+        expect(parseCliTestOptions(commanderOpts, [])).toEqual({
             test_pattern: "foo",
             game_speed: 100,
             log_passed_tests: true,
         });
     });
     it("omits undefined values", () => {
-        expect(parseCliTestOptions({ gameSpeed: 100 })).toEqual({ game_speed: 100 });
+        expect(parseCliTestOptions({ gameSpeed: 100 }, [])).toEqual({ game_speed: 100 });
     });
     it("returns empty object for empty input", () => {
-        expect(parseCliTestOptions({})).toEqual({});
+        expect(parseCliTestOptions({}, [])).toEqual({});
     });
     it("passes through bail option", () => {
-        expect(parseCliTestOptions({ bail: 1 })).toEqual({ bail: 1 });
-        expect(parseCliTestOptions({ bail: 3 })).toEqual({ bail: 3 });
+        expect(parseCliTestOptions({ bail: 1 }, [])).toEqual({ bail: 1 });
+        expect(parseCliTestOptions({ bail: 3 }, [])).toEqual({ bail: 3 });
     });
     it("converts bail=true to bail=1 (commander behavior for --bail without value)", () => {
-        expect(parseCliTestOptions({ bail: true })).toEqual({ bail: 1 });
+        expect(parseCliTestOptions({ bail: true }, [])).toEqual({ bail: 1 });
+    });
+    it("joins positional patterns with OR logic", () => {
+        expect(parseCliTestOptions({}, ["foo", "bar"]).test_pattern).toBe("(foo)|(bar)");
+    });
+    it("positional patterns override CLI testPattern", () => {
+        expect(parseCliTestOptions({ testPattern: "cli" }, ["pos"]).test_pattern).toBe("(pos)");
     });
 });

package/test-output.js

@@ -105,9 +105,34 @@ export class OutputFormatter {
     formatSummary(data) {
         if (!data.summary)
             return;
-        const { status } = data.summary;
-        const color = status === "passed" ? chalk.greenBright : status === "todo" ? chalk.yellowBright : chalk.redBright;
-        console.log("Test run result:", color(status));
+        if (!this.options.quiet) {
+            this.printRecapSection(data.tests, "failed", "Failures:");
+            this.printRecapSection(data.tests, "todo", "Todo:");
+        }
+        this.printCountsLine(data.summary);
+    }
+    printRecapSection(tests, result, header) {
+        const matching = tests.filter((t) => t.result === result);
+        if (matching.length === 0)
+            return;
+        console.log();
+        console.log(header);
+        console.log();
+        for (const test of matching) {
+            this.formatTestResult(test);
+        }
+    }
+    printCountsLine(summary) {
+        const segments = [];
+        if (summary.failed > 0)
+            segments.push(chalk.red(`${summary.failed} failed`));
+        if (summary.todo > 0)
+            segments.push(chalk.magenta(`${summary.todo} todo`));
+        if (summary.skipped > 0)
+            segments.push(chalk.yellow(`${summary.skipped} skipped`));
+        segments.push(chalk.green(`${summary.passed} passed`));
+        const total = summary.passed + summary.failed + summary.skipped + summary.todo;
+        console.log(`Tests: ${segments.join(", ")} (${total} total)`);
     }
     getPrefix(result) {
         switch (result) {

package/test-output.test.js

@@ -200,6 +200,110 @@ describe("OutputFormatter", () => {
         expect(output[0]).toContain("todo test");
     });
 });
+describe("OutputFormatter.formatSummary", () => {
+    let consoleSpy;
+    let output;
+    beforeEach(() => {
+        output = [];
+        consoleSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
+            output.push(args.join(" "));
+        });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    const makeSummary = (overrides = {}) => ({
+        ran: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        todo: 0,
+        cancelled: 0,
+        describeBlockErrors: 0,
+        status: "passed",
+        ...overrides,
+    });
+    it("shows only counts line when no failures or todos", () => {
+        const formatter = new OutputFormatter({});
+        const data = {
+            tests: [{ path: "a", result: "passed", errors: [], logs: [] }],
+            summary: makeSummary({ ran: 1, passed: 1 }),
+        };
+        formatter.formatSummary(data);
+        expect(output.some((l) => l.includes("Tests:"))).toBe(true);
+        expect(output.some((l) => l.includes("1 passed"))).toBe(true);
+        expect(output.some((l) => l.includes("Failures:"))).toBe(false);
+        expect(output.some((l) => l.includes("Todo:"))).toBe(false);
+    });
+    it("shows failure recap and counts line when there are failures", () => {
+        const formatter = new OutputFormatter({});
+        const data = {
+            tests: [
+                { path: "a", result: "passed", errors: [], logs: [] },
+                { path: "b", result: "failed", errors: ["err1"], logs: [], durationMs: 0.5 },
+            ],
+            summary: makeSummary({ ran: 2, passed: 1, failed: 1, status: "failed" }),
+        };
+        formatter.formatSummary(data);
+        expect(output.some((l) => l.includes("Failures:"))).toBe(true);
+        const failLines = output.filter((l) => l.includes("FAIL"));
+        expect(failLines.length).toBeGreaterThanOrEqual(1);
+        expect(output.some((l) => l.includes("1 failed"))).toBe(true);
+        expect(output.some((l) => l.includes("1 passed"))).toBe(true);
+    });
+    it("shows todo recap and counts line when there are todos", () => {
+        const formatter = new OutputFormatter({});
+        const data = {
+            tests: [
+                { path: "a", result: "passed", errors: [], logs: [] },
+                { path: "b", result: "todo", errors: [], logs: [] },
+            ],
+            summary: makeSummary({ ran: 1, passed: 1, todo: 1, status: "todo" }),
+        };
+        formatter.formatSummary(data);
+        expect(output.some((l) => l.includes("Todo:"))).toBe(true);
+        expect(output.some((l) => l.includes("TODO"))).toBe(true);
+        expect(output.some((l) => l.includes("1 todo"))).toBe(true);
+    });
+    it("omits zero-count categories except passed", () => {
+        const formatter = new OutputFormatter({});
+        const data = {
+            tests: [{ path: "a", result: "passed", errors: [], logs: [] }],
+            summary: makeSummary({ ran: 1, passed: 1 }),
+        };
+        formatter.formatSummary(data);
+        const countsLine = output.find((l) => l.includes("Tests:"));
+        expect(countsLine).toContain("1 passed");
+        expect(countsLine).not.toContain("failed");
+        expect(countsLine).not.toContain("skipped");
+        expect(countsLine).not.toContain("todo");
+        expect(countsLine).toContain("(1 total)");
+    });
+    it("includes all non-zero categories in counts line", () => {
+        const formatter = new OutputFormatter({});
+        const data = {
+            tests: [
+                { path: "a", result: "passed", errors: [], logs: [] },
+                { path: "b", result: "failed", errors: ["e"], logs: [] },
+                { path: "c", result: "skipped", errors: [], logs: [] },
+                { path: "d", result: "todo", errors: [], logs: [] },
+            ],
+            summary: makeSummary({ ran: 2, passed: 1, failed: 1, skipped: 1, todo: 1, status: "failed" }),
+        };
+        formatter.formatSummary(data);
+        const countsLine = output.find((l) => l.includes("Tests:"));
+        expect(countsLine).toContain("1 failed");
+        expect(countsLine).toContain("1 todo");
+        expect(countsLine).toContain("1 skipped");
+        expect(countsLine).toContain("1 passed");
+        expect(countsLine).toContain("(4 total)");
+    });
+    it("does nothing when summary is undefined", () => {
+        const formatter = new OutputFormatter({});
+        formatter.formatSummary({ tests: [] });
+        expect(output).toHaveLength(0);
+    });
+});
 describe("OutputPrinter", () => {
     let consoleSpy;
     let output;