@tui-sandbox/library 11.11.1 → 12.0.0

package/src/server/applications/neovim/NeovimApplication.ts

@@ -1,236 +0,0 @@
-import assert from "assert"
-import { exec } from "child_process"
-import EventEmitter from "events"
-import { access } from "fs/promises"
-import type { NeovimClient as NeovimApiClient } from "neovim"
-import { tmpdir } from "os"
-import path, { join } from "path"
-import { debuglog } from "util"
-import type { TestDirectory, TestEnvironmentCommonEnvironmentVariables } from "../../types.js"
-import { DisposableSingleApplication } from "../../utilities/DisposableSingleApplication.js"
-import type { Lazy } from "../../utilities/Lazy.js"
-import { TerminalApplication } from "../../utilities/TerminalApplication.js"
-import { connectNeovimApi } from "./NeovimJavascriptApiClient.js"
-
-const log = debuglog("tui-sandbox-neovim-application")
-
-/*
-
-Usage:
-  nvim [options] [file ...]
-
-Options:
-  --cmd <cmd>           Execute <cmd> before any config
-  +<cmd>, -c <cmd>      Execute <cmd> after config and first file
-  -l <script> [args...] Execute Lua <script> (with optional args)
-  -S <session>          Source <session> after loading the first file
-  -s <scriptin>         Read Normal mode commands from <scriptin>
-  -u <config>           Use this config file
-
-  -d                    Diff mode
-  -es, -Es              Silent (batch) mode
-  -h, --help            Print this help message
-  -i <shada>            Use this shada file
-  -n                    No swap file, use memory only
-  -o[N]                 Open N windows (default: one per file)
-  -O[N]                 Open N vertical windows (default: one per file)
-  -p[N]                 Open N tab pages (default: one per file)
-  -R                    Read-only (view) mode
-  -v, --version         Print version information
-  -V[N][file]           Verbose [level][file]
-
-  --                    Only file names after this
-  --api-info            Write msgpack-encoded API metadata to stdout
-  --clean               "Factory defaults" (skip user config and plugins, shada)
-  --embed               Use stdin/stdout as a msgpack-rpc channel
-  --headless            Don't start a user interface
-  --listen <address>    Serve RPC API from this address
-  --remote[-subcommand] Execute commands remotely on a server
-  --server <address>    Connect to this Nvim server
-  --startuptime <file>  Write startup timing messages to <file>
-
-See ":help startup-options" for all options.
-
-NVIM v0.11.2
-Build type: Release
-LuaJIT 2.1.1741730670
-Run "nvim -V1 -v" for more info
-
-*/
-
-export type StdoutOrStderrMessage = "stdout"
-
-export type StartNeovimGenericArguments = {
-  filename: string | { openInVerticalSplits: string[] }
-  startupScriptModifications?: string[]
-
-  /** Executes the given command with --headless -c <command> -c qa */
-  headlessCmd?: string
-
-  /**
-   * This variable controls the sub-directory that Nvim will read from (and
-   * auto-create) in each of the base directories.
-   *
-   * For example, setting $NVIM_APPNAME to "foo" before starting will cause
-   * Nvim to look for configuration files in $XDG_CONFIG_HOME/foo instead of
-   * $XDG_CONFIG_HOME/nvim. $NVIM_APPNAME must be a name, such as "foo", or a
-   * relative path, such as "foo/bar".
-   *
-   * https://neovim.io/doc/user/starting.html#_nvim_appname
-   */
-  NVIM_APPNAME?: string
-
-  /** Additions to the environment variables for the Neovim process. These
-   * override any already existing environment variables. */
-  additionalEnvironmentVariables?: Record<string, string> | undefined
-}
-
-export type TerminalDimensions = { cols: number; rows: number }
-
-type ResettableState = {
-  testDirectory: TestDirectory
-  NVIM_APPNAME: string | undefined
-  socketPath: string
-  client: Lazy<Promise<NeovimApiClient>>
-}
-
-export class NeovimApplication implements AsyncDisposable {
-  public state: ResettableState | undefined
-  public readonly events: EventEmitter
-
-  public constructor(
-    private readonly testEnvironmentPath: string,
-    public readonly application: DisposableSingleApplication = new DisposableSingleApplication()
-  ) {
-    this.events = new EventEmitter()
-  }
-
-  /**
-   * Kill the current application and start a new one with the given arguments.
-   */
-  public async startNextAndKillCurrent(
-    testDirectory: TestDirectory,
-    startArgs: StartNeovimGenericArguments,
-    terminalDimensions: TerminalDimensions
-  ): Promise<void> {
-    await this[Symbol.asyncDispose]()
-    assert(
-      this.state === undefined,
-      "NeovimApplication state should be undefined after disposing so that no previous state is reused."
-    )
-
-    const neovimArguments: string[] = []
-
-    if (startArgs.startupScriptModifications) {
-      for (const modification of startArgs.startupScriptModifications) {
-        let file = path.join(testDirectory.rootPathAbsolute, "config-modifications", modification)
-        try {
-          await access(file)
-        } catch (e) {
-          throw new Error(`startupScriptModifications file does not exist: ${file}. Error: ${String(e)}`)
-        }
-
-        file = file.replaceAll("'", "\\'")
-        neovimArguments.push("-c", `lua dofile('${file}')`)
-      }
-    }
-
-    if (typeof startArgs.filename === "string") {
-      const file = path.join(testDirectory.rootPathAbsolute, startArgs.filename)
-      neovimArguments.push(file)
-    } else if (startArgs.filename.openInVerticalSplits.length > 0) {
-      // `-O[N]` Open N vertical windows (default: one per file)
-      neovimArguments.push("-O")
-
-      for (const file of startArgs.filename.openInVerticalSplits) {
-        const filePath = path.join(testDirectory.rootPathAbsolute, file)
-        neovimArguments.push(filePath)
-      }
-    }
-
-    if (startArgs.headlessCmd) {
-      // NOTE: update the doc comment above if this changes
-      neovimArguments.push("--headless")
-      neovimArguments.push("-c", startArgs.headlessCmd)
-      neovimArguments.push("-c", "qa")
-    }
-
-    const id = Math.random().toString().slice(2, 8)
-    const socketPath = `${tmpdir()}/tui-sandbox-nvim-socket-${id}`
-    neovimArguments.push("--listen", socketPath)
-
-    const stdout = this.events
-
-    await this.application.startNextAndKillCurrent(async () => {
-      const env = NeovimApplication.getEnvironmentVariables(
-        testDirectory,
-        startArgs.NVIM_APPNAME,
-        startArgs.additionalEnvironmentVariables
-      )
-      return TerminalApplication.start({
-        command: "nvim",
-        args: neovimArguments,
-
-        cwd: this.testEnvironmentPath,
-        env,
-        dimensions: terminalDimensions,
-
-        onStdoutOrStderr(data) {
-          data satisfies string
-          stdout.emit("stdout" satisfies StdoutOrStderrMessage, data)
-        },
-      })
-    })
-
-    const processId = this.application.processId()
-    assert(processId !== undefined, "Neovim was started without a process ID. This is a bug - please open an issue.")
-
-    this.state = {
-      testDirectory,
-      socketPath,
-      NVIM_APPNAME: startArgs.NVIM_APPNAME,
-      client: connectNeovimApi(socketPath),
-    }
-
-    log(`🚀 Started Neovim instance ${processId} (NVIM_APPNAME: ${startArgs.NVIM_APPNAME})`)
-  }
-
-  public static getEnvironmentVariables(
-    testDirectory: TestDirectory,
-    NVIM_APPNAME: string | undefined,
-    additionalEnvironmentVariables?: Record<string, string>
-  ): NodeJS.ProcessEnv {
-    return {
-      ...process.env,
-      ...({
-        HOME: testDirectory.rootPathAbsolute,
-        XDG_CONFIG_HOME: join(testDirectory.rootPathAbsolute, ".config"),
-        XDG_DATA_HOME: join(testDirectory.testEnvironmentPath, ".repro", "data"),
-        TUI_SANDBOX_TEST_ENVIRONMENT_PATH: testDirectory.testEnvironmentPath,
-      } satisfies TestEnvironmentCommonEnvironmentVariables),
-      NVIM_APPNAME: NVIM_APPNAME ?? "nvim",
-
-      ...additionalEnvironmentVariables,
-    }
-  }
-
-  async [Symbol.asyncDispose](): Promise<void> {
-    await this.application[Symbol.asyncDispose]()
-
-    if (!this.state) return
-
-    exec(`rm -rf ${this.state.testDirectory.rootPathAbsolute}`)
-
-    try {
-      await access(this.state.socketPath)
-      // this is probably not dangerous, but I'm not sure why it sometimes
-      // happens. It's better to report it than to hide it.
-      log(`Socket file ${this.state.socketPath} should have been removed by neovim when it exited.`)
-      return
-    } catch {
-      // all good
-    } finally {
-      this.state = undefined
-    }
-  }
-}

package/src/server/applications/neovim/NeovimJavascriptApiClient.test.ts

@@ -1,48 +0,0 @@
-import { access } from "fs/promises"
-import { attach } from "neovim"
-import { afterEach, beforeEach, expect, it, vi } from "vitest"
-import type { PollingInterval } from "./NeovimJavascriptApiClient.js"
-import { connectNeovimApi } from "./NeovimJavascriptApiClient.js"
-
-vi.mock("neovim")
-vi.mock("fs/promises")
-
-const mocked = {
-  attach: vi.mocked(attach),
-  access: vi.mocked(access),
-  log: vi.spyOn(console, "log").mockImplementation(() => {
-    //
-  }),
-}
-const pollingInterval = 100 satisfies PollingInterval
-
-beforeEach(() => {
-  vi.useFakeTimers()
-})
-
-afterEach(() => {
-  vi.useRealTimers()
-})
-
-it("is lazy - does not connect right away", async () => {
-  mocked.access.mockRejectedValue(new Error("no such file or directory"))
-  connectNeovimApi("foosocket")
-
-  vi.advanceTimersByTime(pollingInterval)
-  expect(mocked.attach).not.toHaveBeenCalled()
-})
-
-it("connects right away if the socket file is already there", async () => {
-  mocked.access.mockResolvedValue(undefined)
-  const lazyClient = connectNeovimApi("foosocket")
-  await lazyClient.get()
-
-  vi.advanceTimersByTime(pollingInterval)
-  expect(mocked.attach).toHaveBeenCalledWith({
-    socket: "foosocket",
-    options: {
-      logger: expect.any(Object) as never,
-    },
-  } satisfies Partial<Parameters<typeof attach>[0]>)
-  expect(mocked.attach).toHaveBeenCalledTimes(1)
-})

package/src/server/applications/neovim/NeovimJavascriptApiClient.ts

@@ -1,68 +0,0 @@
-import { access } from "fs/promises"
-import type { NeovimClient as NeovimApiClient } from "neovim"
-import { attach } from "neovim"
-import { createLogger, format, transports } from "winston"
-import { Lazy } from "../../utilities/Lazy.js"
-
-// const log = debuglog("tui-sandbox.neovim.NeovimJavascriptApiClient")
-
-export type NeovimJavascriptApiClient = NeovimApiClient
-
-export type PollingInterval = 100
-
-export function connectNeovimApi(socketPath: string): Lazy<Promise<NeovimJavascriptApiClient>> {
-  // When a custom logger is provided to attach(), we can hide debug level log
-  // messages
-  //
-  // https://github.com/neovim/node-client/blob/e0568e32e0fc8837ad900146bfd5ca27b9416235/README.md#logging
-  const logger = createLogger({
-    level: "warn",
-
-    transports: [
-      new transports.Console({
-        format: format.combine(
-          format(info => {
-            if ((info.message as string).startsWith("failed request to")) {
-              // This is logged when neovim is started with --embed, which we don't use.
-              // It's not a problem, so hide it.
-              //
-              // Returning false removes this log entry
-              return false
-            }
-
-            return info
-          })(),
-          format.colorize(),
-          format.simple()
-        ),
-      }),
-    ],
-  })
-
-  // it takes about 100ms for the socket file to be created - best make this
-  // Lazy so that we don't wait for it unnecessarily.
-  return new Lazy(async () => {
-    for (let i = 0; i < 100; i++) {
-      try {
-        await access(socketPath)
-        // log(`socket file ${socketPath} created after at attempt ${i + 1}`)
-        break
-      } catch {
-        // log(`polling for socket file ${socketPath} to be created (attempt ${i + 1})`)
-        await new Promise(resolve => setTimeout(resolve, 100 satisfies PollingInterval))
-      }
-    }
-
-    // Prevent neovim node client from monkey patching console.log. It runs in
-    // a separate process entirely, so there doesn't seem to be any benefit to
-    // this.
-    process.env["ALLOW_CONSOLE"] = "1"
-
-    return attach({
-      socket: socketPath,
-      options: {
-        logger,
-      },
-    })
-  })
-}

package/src/server/applications/neovim/api.ts

@@ -1,257 +0,0 @@
-import assert from "assert"
-import { access } from "fs/promises"
-import path from "path"
-import { debuglog } from "util"
-import type { BlockingCommandInput } from "../../blockingCommandInputSchema.js"
-import type {
-  BlockingShellCommandOutput,
-  RunExCommandOutput,
-  RunLuaCodeOutput,
-  StartNeovimGenericArguments,
-  TestDirectory,
-} from "../../types.js"
-import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
-import { convertEventEmitterToAsyncGenerator } from "../../utilities/generator.js"
-import { Lazy } from "../../utilities/Lazy.js"
-import type { TabId } from "../../utilities/tabId.js"
-import { timeout } from "../../utilities/timeout.js"
-import { executeBlockingShellCommand } from "../terminal/runBlockingShellCommand.js"
-import type { StdoutOrStderrMessage, TerminalDimensions } from "./NeovimApplication.js"
-import { NeovimApplication } from "./NeovimApplication.js"
-import type { ExCommandInput, LuaCodeInput } from "./neovimRouter.js"
-import { prepareNewTestDirectory } from "./prepareNewTestDirectory.js"
-
-const neovims = new Map<TabId["tabId"], NeovimApplication>()
-const resources: Lazy<AsyncDisposableStack> = new Lazy(() => {
-  return new AsyncDisposableStack()
-})
-
-const log = debuglog("tui-sandbox.neovim.api")
-
-export async function installDependencies(NVIM_APPNAME: string | undefined, config: TestServerConfig): Promise<void> {
-  await using app = new NeovimApplication(config.directories.testEnvironmentPath)
-  const testDirectory = await prepareNewTestDirectory(config)
-  const prepareFilePath = path.join(testDirectory.rootPathAbsolute, ".config", NVIM_APPNAME ?? "nvim", "prepare.lua")
-  try {
-    await access(prepareFilePath)
-  } catch {
-    // show the output here because it's typically shown in the console before
-    // the tests start. It's also sensitive to outside changes.
-    //
-    // eslint-disable-next-line no-restricted-properties
-    console.log(
-      `Neovim prepareFilePath does not exist: ${prepareFilePath}. If you want to run a prepare script before starting the tests, create it.`
-    )
-    return
-  }
-
-  // eslint-disable-next-line no-restricted-properties
-  console.log(`🚀 Running Neovim prepareFilePath ${prepareFilePath}...`)
-
-  let output = ""
-  app.events.on("stdout" satisfies StdoutOrStderrMessage, data => {
-    assert(data)
-    assert(typeof data === "string")
-    output += data
-  })
-  await app.startNextAndKillCurrent(
-    testDirectory,
-    {
-      filename: "empty.txt",
-      headlessCmd: `lua dofile("${prepareFilePath}")`,
-      NVIM_APPNAME,
-    },
-    { cols: 80, rows: 24 }
-  )
-  await app.application.untilExit()
-  // eslint-disable-next-line no-restricted-properties
-  console.log(`🚀 Neovim installDependencies output:`)
-  // eslint-disable-next-line no-restricted-properties
-  console.log(output)
-}
-
-export async function initializeStdout(
-  options: { client: TabId },
-  signal: AbortSignal | undefined,
-  testEnvironmentPath: string
-): Promise<AsyncGenerator<string, void, unknown>> {
-  const tabId = options.client.tabId
-  const neovim = neovims.get(tabId) ?? new NeovimApplication(testEnvironmentPath)
-  if (neovims.get(tabId) === undefined) {
-    neovims.set(tabId, neovim)
-    resources.get().use(neovim)
-  }
-
-  const stdout = convertEventEmitterToAsyncGenerator(neovim.events, "stdout" satisfies StdoutOrStderrMessage)
-  if (signal) {
-    signal.addEventListener("abort", () => {
-      void neovim[Symbol.asyncDispose]().finally(() => {
-        neovims.delete(tabId)
-      })
-    })
-  }
-
-  return stdout
-}
-
-export async function start(
-  options: StartNeovimGenericArguments,
-  terminalDimensions: TerminalDimensions,
-  tabId: TabId,
-  config: TestServerConfig
-): Promise<TestDirectory> {
-  const neovim = neovims.get(tabId.tabId)
-  assert(neovim, `Neovim instance not found for client id ${tabId.tabId}`)
-
-  const testDirectory = await prepareNewTestDirectory(config)
-  await neovim.startNextAndKillCurrent(testDirectory, options, terminalDimensions)
-
-  return testDirectory
-}
-
-export async function sendStdin(options: { tabId: TabId; data: string }): Promise<void> {
-  const neovim = neovims.get(options.tabId.tabId)
-  assert(
-    neovim !== undefined,
-    `Neovim instance for clientId not found - cannot send stdin. Maybe it's not started yet?`
-  )
-  assert(
-    neovim.application,
-    `Neovim application not found for client id ${options.tabId.tabId}. Maybe it's not started yet?`
-  )
-
-  await neovim.application.write(options.data)
-}
-
-export async function runBlockingShellCommand(
-  signal: AbortSignal | undefined,
-  input: BlockingCommandInput,
-  allowFailure: boolean
-): Promise<BlockingShellCommandOutput> {
-  const neovim = neovims.get(input.tabId.tabId)
-  assert(
-    neovim !== undefined,
-    `Neovim instance for clientId not found - cannot run blocking shell command. Maybe neovim's not started yet?`
-  )
-  const testDirectory = neovim.state?.testDirectory
-  assert(testDirectory, `Test directory not found for client id ${input.tabId.tabId}. Maybe neovim's not started yet?`)
-
-  const env = NeovimApplication.getEnvironmentVariables(testDirectory, neovim.state?.NVIM_APPNAME, input.envOverrides)
-  return executeBlockingShellCommand(testDirectory, input, signal, allowFailure, env)
-}
-
-export async function runLuaCode(options: LuaCodeInput): Promise<RunLuaCodeOutput> {
-  const neovim = neovims.get(options.tabId.tabId)
-  assert(
-    neovim !== undefined,
-    `Neovim instance for clientId not found - cannot run Lua code. Maybe neovim's not started yet?`
-  )
-  assert(
-    neovim.application,
-    `Neovim application not found for client id ${options.tabId.tabId}. Maybe it's not started yet?`
-  )
-
-  const api = await neovim.state?.client.get()
-  if (!api) {
-    throw new Error(`Neovim API not available for client id ${options.tabId.tabId}. Maybe it's not started yet?`)
-  }
-
-  log(`Neovim ${neovim.application.processId()} running Lua code: ${options.luaCode}`)
-  try {
-    const value = await api.lua(options.luaCode)
-    return { value }
-  } catch (e) {
-    console.warn(`Error running Lua code: ${options.luaCode}`, e)
-    throw new Error(`Error running Lua code: ${options.luaCode}`, { cause: e })
-  }
-}
-
-export type PollLuaCodeInput = {
-  luaAssertion: string
-  tabId: TabId
-}
-
-export async function waitForLuaCode(
-  options: PollLuaCodeInput,
-  signal: AbortSignal | undefined
-): Promise<RunLuaCodeOutput> {
-  const neovim = neovims.get(options.tabId.tabId)
-  assert(
-    neovim !== undefined,
-    `Neovim instance for clientId not found - cannot pollLuaCode. Maybe neovim's not started yet?`
-  )
-  assert(
-    neovim.application,
-    `Neovim application not found for client id ${options.tabId.tabId}. Maybe it's not started yet?`
-  )
-
-  const api = await neovim.state?.client.get()
-  if (!api) {
-    throw new Error(`Neovim API not available for client id ${options.tabId.tabId}. Maybe it's not started yet?`)
-  }
-
-  log(`Neovim ${neovim.application.processId()} polling Lua code: ${options.luaAssertion}`)
-
-  let running: boolean = true
-  signal?.addEventListener("abort", () => {
-    log(`Polling Lua code: '${options.luaAssertion}' was aborted via signal`)
-    running = false
-  })
-
-  const failureMessages = new Set<string>()
-  const reportFailure = () => {
-    console.warn(`Polling Lua code: '${options.luaAssertion}' failed. Failure messages:`, failureMessages)
-  }
-
-  const maxIterations = 100
-  for (let iteration = 1; iteration <= maxIterations; iteration++) {
-    if (!running) {
-      reportFailure()
-      throw new Error(`Polling Lua code: '${options.luaAssertion}' was aborted after ${iteration} iterations`)
-    }
-
-    try {
-      const value = await api.lua(options.luaAssertion)
-      log(`Lua code assertion passed: ${options.luaAssertion} (iteration ${iteration})`)
-
-      return { value }
-    } catch (e) {
-      failureMessages.add(String(e))
-      await timeout(100)
-    }
-  }
-
-  reportFailure()
-  throw new Error(
-    `Polling Lua code: '${options.luaAssertion}' always raised an error after ${maxIterations} iterations`
-  )
-}
-
-export async function runExCommand(options: ExCommandInput): Promise<RunExCommandOutput> {
-  const neovim = neovims.get(options.tabId.tabId)
-  assert(
-    neovim !== undefined,
-    `Neovim instance for clientId not found - cannot runExCommand. Maybe neovim's not started yet?`
-  )
-  assert(
-    neovim.application,
-    `Neovim application not found for client id ${options.tabId.tabId}. Maybe it's not started yet?`
-  )
-
-  const api = await neovim.state?.client.get()
-  if (!api) {
-    throw new Error(`Neovim API not available for client id ${options.tabId.tabId}. Maybe it's not started yet?`)
-  }
-
-  log(`Neovim ${neovim.application.processId()} running Ex command: ${options.command}`)
-  try {
-    const output = await api.commandOutput(options.command)
-    if (options.log) {
-      console.info(`:${options.command} output: ${output}`)
-    }
-    return { value: output }
-  } catch (e) {
-    console.warn(`Error running Ex command: ${options.command}`, e)
-    throw new Error(`Error running Ex command: ${options.command}`, { cause: e })
-  }
-}

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

@@ -1,18 +0,0 @@
-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,29 +0,0 @@
-import nodePath from "path"
-import type { PartialDeep } from "type-fest"
-import { expect, it, vi } from "vitest"
-import { createDefaultConfig } from "../../../config.js"
-import type { TestServerConfig } from "../../../updateTestdirectorySchemaFile.js"
-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())
-
-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()
-  const result = await createTempDir({
-    ...createDefaultConfig("cwd", {}),
-    directories: {
-      testEnvironmentPath: dir.path,
-      outputFilePath: nodePath.join(dir.path, "MyTestDirectory.ts"),
-      latestSymlinkName: "latest",
-    },
-  } satisfies PartialDeep<TestServerConfig>)
-
-  expect(result.contents).toEqual({})
-  expect(result.testEnvironmentPath).toEqual(dir.path)
-  expect(result.testEnvironmentPath.includes("test-temp-dir-" satisfies TestTempDirPrefix)).toBeTruthy()
-  expect(result.testEnvironmentPathRelative.includes("testdirs" satisfies TestDirsPath)).toBeTruthy()
-})