@tui-sandbox/library 11.6.7 → 11.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tui-sandbox/library",
-  "version": "11.6.7",
+  "version": "11.7.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/mikavilpas/tui-sandbox"
@@ -25,9 +25,10 @@
     "neovim": "5.3.0",
     "node-pty": "1.0.0",
     "prettier": "3.6.2",
+    "tsx": "4.20.5",
     "type-fest": "4.41.0",
     "winston": "3.17.0",
-    "zod": "4.1.4"
+    "zod": "4.1.5"
   },
   "devDependencies": {
     "@types/command-exists": "1.2.3",
@@ -35,7 +36,6 @@
     "@types/express": "5.0.3",
     "@types/node": "24.3.0",
     "nodemon": "3.1.10",
-    "tsx": "4.20.5",
     "vite": "7.1.3",
     "vitest": "3.2.4"
   },

package/src/scripts/commands/commandTuiNeovimExec.ts

@@ -1,9 +1,9 @@
 import { NeovimApplication, type StdoutOrStderrMessage } from "../../server/applications/neovim/NeovimApplication.js"
 import { prepareNewTestDirectory } from "../../server/applications/neovim/prepareNewTestDirectory.js"
+import type { TestServerConfig } from "../../server/updateTestdirectorySchemaFile.js"
 import type { NeovimExec } from "../parseArguments.js"
-import { config } from "../tui.js"
 
-export async function commandTuiNeovimExec(command: NeovimExec): Promise<void> {
+export async function commandTuiNeovimExec(command: NeovimExec, config: TestServerConfig): Promise<void> {
   // automatically dispose of the neovim instance when done
   await using app = new NeovimApplication(config.directories.testEnvironmentPath)
   app.events.on("stdout" satisfies StdoutOrStderrMessage, data => {

package/src/scripts/commands/commandTuiNeovimPrepare.ts

@@ -1,7 +1,7 @@
 import { installDependencies } from "../../server/applications/neovim/api.js"
-import { config } from "../tui.js"
+import type { TestServerConfig } from "../../server/updateTestdirectorySchemaFile.js"
 
-export async function commandTuiNeovimPrepare(): Promise<void> {
+export async function commandTuiNeovimPrepare(config: TestServerConfig): Promise<void> {
   const NVIM_APPNAME = process.env["NVIM_APPNAME"]
   console.log(`🚀 Installing neovim dependencies${NVIM_APPNAME ? ` for NVIM_APPNAME=${NVIM_APPNAME}` : ""}...`)
   await installDependencies(

package/src/scripts/commands/commandTuiStart.ts

@@ -1,10 +1,11 @@
 import path from "path"
 import { createCypressSupportFile } from "../../server/cypress-support/createCypressSupportFile.js"
 import { startTestServer } from "../../server/server.js"
+import type { TestServerConfig } from "../../server/updateTestdirectorySchemaFile.js"
 import { updateTestdirectorySchemaFile } from "../../server/updateTestdirectorySchemaFile.js"
-import { config, cwd } from "../tui.js"
+import { cwd } from "../tui.js"
 
-export async function commandTuiStart(): Promise<void> {
+export async function commandTuiStart(config: TestServerConfig): Promise<void> {
   try {
     await createCypressSupportFile({
       cypressSupportDirectoryPath: path.join(cwd, "cypress", "support"),

package/src/scripts/resolveConfig.test.ts

@@ -0,0 +1,73 @@
+import assert from "assert"
+import { writeFile } from "fs/promises"
+import { expect } from "vitest"
+import { TempDirectory } from "../server/applications/neovim/environment/TempDirectory.js"
+import type { TestServerConfig } from "../server/updateTestdirectorySchemaFile.js"
+import { testServerConfigSchema } from "../server/updateTestdirectorySchemaFile.js"
+import type { ResolveTuiConfigResult, ResolveTuiConfigResultSuccess } from "./resolveTuiConfig.js"
+import { resolveTuiConfig } from "./resolveTuiConfig.js"
+
+it("defaults to the default configuration if no config file is found", async () => {
+  const config = await resolveTuiConfig(__dirname)
+  assert(!config.error)
+  expect(config.id).toBe("no-config-found" satisfies ResolveTuiConfigResultSuccess["id"])
+  expect(testServerConfigSchema.safeParse(config.result).success).toBe(true)
+})
+
+it("loads a custom configuration file if it exists", async () => {
+  using dir = TempDirectory.create()
+
+  const customConfig: TestServerConfig = {
+    directories: {
+      testEnvironmentPath: "./test-environment2/",
+      outputFilePath: "./output.ts",
+    },
+    port: 12345,
+  }
+  {
+    const filename = `${dir.path}/tui-sandbox.config.ts`
+    const contents = `export const config = ${JSON.stringify(customConfig)}`
+    await writeFile(filename, contents)
+  }
+
+  const config = await resolveTuiConfig(dir.path)
+  expect(config).toStrictEqual({
+    id: "custom-config",
+    result: customConfig,
+  } satisfies ResolveTuiConfigResult)
+})
+
+it("uses the default configuration file if the config has invalid contents", async () => {
+  using dir = TempDirectory.create()
+
+  {
+    const customConfig: TestServerConfig = {
+      // @ts-expect-error testing an invalid config on purpose
+      directories: undefined,
+      port: 12345,
+    }
+    const filename = `${dir.path}/tui-sandbox.config.ts`
+    const contents = `export const config = ${JSON.stringify(customConfig)}`
+    await writeFile(filename, contents)
+  }
+
+  const result = await resolveTuiConfig(dir.path)
+  assert(result.error)
+  expect(result.configFilePath).contains(dir.path)
+  expect(result.message).match(/Issues found in the config file/)
+})
+
+it("fails if the config has not been exported from the config file", async () => {
+  using dir = TempDirectory.create()
+
+  {
+    const filename = `${dir.path}/tui-sandbox.config.ts`
+    const contents = ``
+    await writeFile(filename, contents)
+  }
+
+  const result = await resolveTuiConfig(dir.path)
+  assert(result.error)
+  expect(result.configFilePath).contains(dir.path)
+  expect(result.message).match(/Issues found in the config file/)
+})

package/src/scripts/resolveTuiConfig.ts

@@ -0,0 +1,59 @@
+import assert from "assert"
+import { resolve } from "path/posix"
+import { pathToFileURL } from "url"
+import { debuglog } from "util"
+import * as z from "zod"
+import { createDefaultConfig } from "../server/config.js"
+import { type TestServerConfig, testServerConfigSchema } from "../server/updateTestdirectorySchemaFile.js"
+
+const log = debuglog("tui-sandbox.resolveConfig")
+
+export type ResolveTuiConfigResultSuccess = {
+  id: "default-config" | "custom-config" | "no-config-found"
+  result: TestServerConfig
+  error?: never
+}
+export type ResolveTuiConfigResultError = {
+  error: object
+  configFilePath: string
+  message: string
+}
+
+export type ResolveTuiConfigResult = ResolveTuiConfigResultSuccess | ResolveTuiConfigResultError
+
+export const resolveTuiConfig = async (cwd: string): Promise<ResolveTuiConfigResult> => {
+  const defaultConfig = createDefaultConfig(cwd, process.env)
+
+  const url = pathToFileURL(resolve(cwd, "tui-sandbox.config.ts"))
+
+  let file: unknown
+  try {
+    // loading typescript files works when using https://tsx.is/
+    file = await import(url.href)
+    log(`Found configuration file in ${url.pathname}:`, JSON.stringify(file, null, 2))
+  } catch (e) {
+    console.log("Using the default configuration.")
+    log("Config load error:", e)
+
+    return {
+      id: "no-config-found",
+      result: defaultConfig,
+    }
+  }
+
+  assert(file)
+  const customConfigSchema = z.strictObject({ config: testServerConfigSchema })
+  const customConfig = customConfigSchema.safeParse(file)
+  if (customConfig.success) {
+    return {
+      id: "custom-config",
+      result: customConfig.data.config,
+    }
+  } else {
+    return {
+      error: z.treeifyError(customConfig.error),
+      configFilePath: url.pathname,
+      message: `Issues found in the config file`,
+    }
+  }
+}

package/src/scripts/tui.ts

@@ -1,12 +1,11 @@
 import assert from "node:assert"
-import path from "node:path"
-import type { TestServerConfig } from "../server/index.js"
 import type { TestResultExitCode } from "./commands/commandRun.js"
 import { commandRun } from "./commands/commandRun.js"
 import { commandTuiNeovimExec } from "./commands/commandTuiNeovimExec.js"
 import { commandTuiNeovimPrepare } from "./commands/commandTuiNeovimPrepare.js"
 import { commandTuiStart } from "./commands/commandTuiStart.js"
 import { parseArguments } from "./parseArguments.js"
+import { resolveTuiConfig } from "./resolveTuiConfig.js"
 
 //
 // This is the main entrypoint to tui-sandbox
@@ -21,18 +20,14 @@ if (major < 24) {
   process.exit(1)
 }
 
-const outputFileName = "MyTestDirectory.ts"
-
 /** The cwd in the user's directory when they are running this script. Not the
  * cwd of the script itself. */
 export const cwd = process.cwd()
-export const config = {
-  directories: {
-    testEnvironmentPath: path.join(cwd, "test-environment/"),
-    outputFilePath: path.join(cwd, outputFileName),
-  },
-  port: process.env["PORT"] ? parseInt(process.env["PORT"]) : 3000,
-} satisfies TestServerConfig
+const configResult = await resolveTuiConfig(cwd)
+if (configResult.error) {
+  console.error(configResult.message, configResult.error)
+  process.exit(1)
+}
 
 // the arguments passed to this script start at index 2
 const args = process.argv.slice(2)
@@ -41,15 +36,15 @@ const command = await parseArguments(args)
 
 switch (command?.action) {
   case "neovim prepare": {
-    await commandTuiNeovimPrepare()
+    await commandTuiNeovimPrepare(configResult.result)
     break
   }
   case "neovim exec": {
-    await commandTuiNeovimExec(command)
+    await commandTuiNeovimExec(command, configResult.result)
     break
   }
   case "start": {
-    await commandTuiStart()
+    await commandTuiStart(configResult.result)
     break
   }
   case "run": {

package/src/server/applications/neovim/environment/TempDirectory.ts

@@ -0,0 +1,18 @@
+import fs from "fs"
+import nodePath from "path"
+
+export type TestTempDirPrefix = "test-temp-dir-"
+
+export class TempDirectory implements Disposable {
+  private constructor(public readonly path: string) {}
+
+  public static create(): TempDirectory {
+    const tmp = fs.mkdtempSync("test-temp-dir-" satisfies TestTempDirPrefix)
+    const absolutePath = nodePath.resolve(tmp)
+    return new TempDirectory(absolutePath)
+  }
+
+  [Symbol.dispose](): void {
+    fs.rmdirSync(this.path, { recursive: true, maxRetries: 5 })
+  }
+}

package/src/server/applications/neovim/environment/createTempDir.test.ts

@@ -1,27 +1,12 @@
-import fs from "fs"
 import nodePath from "path"
 import { expect, it, vi } from "vitest"
 import type { TestDirsPath } from "./createTempDir.js"
 import { createTempDir } from "./createTempDir.js"
+import type { TestTempDirPrefix } from "./TempDirectory.js"
+import { TempDirectory } from "./TempDirectory.js"
 
 vi.spyOn(console, "log").mockImplementation(vi.fn())
 
-type TestTempDirPrefix = "test-temp-dir-"
-
-class TempDirectory implements Disposable {
-  constructor(public readonly path: string) {}
-
-  public static create(): TempDirectory {
-    const tmp = fs.mkdtempSync("test-temp-dir-" satisfies TestTempDirPrefix)
-    const absolutePath = nodePath.resolve(tmp)
-    return new TempDirectory(absolutePath)
-  }
-
-  [Symbol.dispose](): void {
-    fs.rmdirSync(this.path, { recursive: true, maxRetries: 5 })
-  }
-}
-
 it("should create a temp dir with no contents", async () => {
   // typically the user will want to have contents, but this should not be an error
   using dir = TempDirectory.create()

package/src/server/config.ts

@@ -0,0 +1,11 @@
+import path from "path"
+import type { TestServerConfig } from "./updateTestdirectorySchemaFile.js"
+
+export const createDefaultConfig = (cwd: string, environment: NodeJS.ProcessEnv): TestServerConfig =>
+  ({
+    directories: {
+      testEnvironmentPath: path.join(cwd, "test-environment/"),
+      outputFilePath: path.join(cwd, "MyTestDirectory.ts"),
+    },
+    port: environment["PORT"] ? parseInt(environment["PORT"]) : 3000,
+  }) satisfies TestServerConfig

package/src/server/updateTestdirectorySchemaFile.ts

@@ -1,18 +1,20 @@
 import { readFileSync, writeFileSync } from "fs"
 import { debuglog } from "util"
+import * as z from "zod"
 import { buildTestDirectorySchema } from "./dirtree/index.js"
 
 const log = debuglog("tui-sandbox.updateTestdirectorySchemaFile")
 
-export type DirectoriesConfig = {
-  testEnvironmentPath: string
-  outputFilePath: string
-}
+export type DirectoriesConfig = TestServerConfig["directories"]
 
-export type TestServerConfig = {
-  directories: DirectoriesConfig
-  port: number
-}
+export type TestServerConfig = z.output<typeof testServerConfigSchema>
+export const testServerConfigSchema = z.strictObject({
+  directories: z.object({
+    testEnvironmentPath: z.string(),
+    outputFilePath: z.string(),
+  }),
+  port: z.number().int().min(1).max(65535),
+})
 
 export type UpdateTestdirectorySchemaFileResult = "updated" | "did-nothing"