@tui-sandbox/library 11.11.2 → 12.0.0

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

@@ -1,91 +0,0 @@
-import assert from "assert"
-import { execSync } from "child_process"
-import { constants, readdirSync, statSync } from "fs"
-import { access, mkdir, mkdtemp, symlink } from "fs/promises"
-import path from "path"
-import { debuglog } from "util"
-import { convertDree, getDirectoryTree } from "../../../dirtree/index.js"
-import type { TestDirectory } from "../../../types.js"
-import type { TestServerConfig } from "../../../updateTestdirectorySchemaFile.js"
-import { updateTestdirectorySchemaFile } from "../../../updateTestdirectorySchemaFile.js"
-
-const log = debuglog("tui-sandbox.createTempDir")
-
-export async function createTempDir(config: TestServerConfig): Promise<TestDirectory> {
-  try {
-    // before calling this function, the testEnvironmentPath should already exist
-    statSync(config.directories.testEnvironmentPath)
-    const dir = await createUniqueDirectory(config.directories.testEnvironmentPath)
-
-    readdirSync(config.directories.testEnvironmentPath).forEach(entry => {
-      if (entry === ("testdirs" satisfies TestDirsPath)) return
-      if (entry === ".repro") return
-
-      execSync(`cp -R '${path.join(config.directories.testEnvironmentPath, entry)}' ${dir}/`)
-    })
-    log(`Created test directory at ${dir}`)
-
-    const tree = convertDree(getDirectoryTree(dir).dree)
-    assert(tree.type === "directory")
-
-    const [_, latestEnvironmentSymlink] = await Promise.all([
-      updateTestdirectorySchemaFile(config),
-      createLatestSymlink(config, dir),
-    ])
-    return {
-      rootPathAbsolute: dir,
-      contents: tree.contents,
-      testEnvironmentPath: config.directories.testEnvironmentPath,
-      testEnvironmentPathRelative: path.relative(config.directories.testEnvironmentPath, dir),
-      latestEnvironmentSymlink,
-    }
-  } catch (err) {
-    console.error(err)
-    throw err
-  }
-}
-
-export type TestDirsPath = "testdirs"
-
-async function createUniqueDirectory(testEnvironmentPath: string): Promise<string> {
-  const testdirs = path.join(testEnvironmentPath, "testdirs" satisfies TestDirsPath)
-  try {
-    await access(testdirs, constants.F_OK)
-  } catch {
-    await mkdir(testdirs)
-  }
-  const dir = await mkdtemp(path.join(testdirs, "dir-"))
-  assert(typeof dir === "string")
-
-  return dir
-}
-
-async function createLatestSymlink(config: TestServerConfig, uniqueTestDirectory: string): Promise<string> {
-  const latestSymlinkPath = path.join(
-    config.directories.testEnvironmentPath,
-    "testdirs" satisfies TestDirsPath,
-    config.directories.latestSymlinkName
-  )
-  try {
-    await access(latestSymlinkPath, constants.F_OK)
-    // If it already exists, remove it
-    execSync(`rm -f '${latestSymlinkPath}'`)
-  } catch {
-    // It doesn't exist, that's fine
-  }
-
-  // recreate it
-  await symlink(uniqueTestDirectory, latestSymlinkPath, "junction")
-
-  return latestSymlinkPath
-}
-
-export async function removeTestDirectories(testEnvironmentPath: string): Promise<void> {
-  try {
-    const testdirs = path.join(testEnvironmentPath, "testdirs" satisfies TestDirsPath)
-    await access(testdirs, constants.F_OK)
-    execSync(`rm -rf ${testdirs}/*`)
-  } catch (e) {
-    console.debug("Could not remove test directories, maybe they don't exist yet", e)
-  }
-}

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

@@ -1,100 +0,0 @@
-import type { Except } from "type-fest"
-import * as z from "zod"
-import { blockingCommandInputSchema } from "../../blockingCommandInputSchema.js"
-import { trpc } from "../../connection/trpc.js"
-import { serverTestDirectorySchema } from "../../types.js"
-import type { NeovimIntegrationDefaultAppName, TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
-import { tabIdSchema } from "../../utilities/tabId.js"
-import { timeoutable } from "../../utilities/timeoutable.js"
-import * as neovim from "./api.js"
-
-const luaCodeInputSchema = z.object({ tabId: tabIdSchema, luaCode: z.string() })
-export type LuaCodeClientInput = Except<LuaCodeInput, "tabId">
-export type LuaCodeInput = z.infer<typeof luaCodeInputSchema>
-
-const pollLuaCodeInputSchema = z.object({
-  tabId: tabIdSchema,
-  luaAssertion: z.string(),
-  timeoutMs: z.number().optional().default(10_000),
-})
-export type PollLuaCodeClientInput = Except<z.input<typeof pollLuaCodeInputSchema>, "tabId">
-
-const exCommandInputSchema = z.object({
-  tabId: tabIdSchema,
-  command: z.string(),
-  log: z.boolean().optional(),
-})
-export type ExCommandClientInput = Except<ExCommandInput, "tabId">
-export type ExCommandInput = z.infer<typeof exCommandInputSchema>
-
-const runLuaFileInputSchema = z.object({
-  tabId: tabIdSchema,
-  luaFile: z.string(),
-  log: z.boolean().optional(),
-})
-export type RunLuaFileInput = z.output<typeof runLuaFileInputSchema>
-export type RunLuaFileClientInput = Except<RunLuaFileInput, "tabId">
-
-// let trpc infer the type as that is what it is designed to do
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function createNeovimRouter(config: TestServerConfig) {
-  return trpc.router({
-    start: trpc.procedure
-      .input(
-        z.object({
-          tabId: tabIdSchema,
-          startNeovimArguments: z.object({
-            filename: z.union([
-              z.string(),
-              z.object({
-                openInVerticalSplits: z.array(z.string()),
-              }),
-            ]),
-            startupScriptModifications: z.array(z.string()).optional(),
-            additionalEnvironmentVariables: z.record(z.string(), z.string()).optional(),
-            NVIM_APPNAME: z
-              .string()
-              .optional()
-              .default("nvim" satisfies NeovimIntegrationDefaultAppName),
-          }),
-          terminalDimensions: z.object({
-            cols: z.number(),
-            rows: z.number(),
-          }),
-        })
-      )
-      .output(serverTestDirectorySchema)
-      .mutation(async options => {
-        return neovim.start(
-          options.input.startNeovimArguments,
-          options.input.terminalDimensions,
-          options.input.tabId,
-          config
-        )
-      }),
-
-    onStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
-      return neovim.initializeStdout(options.input, options.signal, config.directories.testEnvironmentPath)
-    }),
-    sendStdin: trpc.procedure.input(z.object({ tabId: tabIdSchema, data: z.string() })).mutation(options => {
-      return neovim.sendStdin(options.input)
-    }),
-
-    runBlockingShellCommand: trpc.procedure.input(blockingCommandInputSchema).mutation(async options => {
-      return neovim.runBlockingShellCommand(options.signal, options.input, options.input.allowFailure ?? false)
-    }),
-
-    runLuaCode: trpc.procedure.input(luaCodeInputSchema).mutation(options => {
-      return timeoutable(10_000, neovim.runLuaCode(options.input))
-    }),
-
-    waitForLuaCode: trpc.procedure.input(pollLuaCodeInputSchema).mutation(async options => {
-      const result = await timeoutable(options.input.timeoutMs, neovim.waitForLuaCode(options.input, options.signal))
-      return result
-    }),
-
-    runExCommand: trpc.procedure.input(exCommandInputSchema).mutation(options => {
-      return timeoutable(10_000, neovim.runExCommand(options.input))
-    }),
-  })
-}

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

@@ -1,32 +0,0 @@
-import { rm } from "fs/promises"
-import path from "path"
-import type { PartialDeep } from "type-fest"
-import { assert, describe, expect, it } from "vitest"
-import { createDefaultConfig } from "../../config.js"
-import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
-import { prepareNewTestDirectory } from "./prepareNewTestDirectory.js"
-
-describe("prepareNewTestDirectory when the testEnvironmentPath does not exist", () => {
-  it("should be able to create a new test directory", async () => {
-    // this happens when starting a new project, and the directory structure
-    // has not been created yet
-    const testEnvironmentPath = "/tmp/test"
-    const testDirectory = await prepareNewTestDirectory({
-      ...createDefaultConfig("cwd", {}),
-      directories: {
-        outputFilePath: path.join(testEnvironmentPath, "foo.ts"),
-        testEnvironmentPath,
-        latestSymlinkName: "latest",
-      },
-    } satisfies PartialDeep<TestServerConfig>)
-
-    try {
-      expect(testDirectory.contents).toEqual({})
-      expect(testDirectory.testEnvironmentPath).toEqual("/tmp/test")
-    } finally {
-      // for safety, only remove inside /tmp
-      assert(testEnvironmentPath.startsWith("/tmp/"))
-      await rm(testEnvironmentPath, { recursive: true })
-    }
-  })
-})

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

@@ -1,21 +0,0 @@
-import { access, mkdir } from "fs/promises"
-import { debuglog } from "util"
-import type { TestDirectory } from "../../types.js"
-import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
-import { createTempDir, removeTestDirectories } from "./environment/createTempDir.js"
-
-const log = debuglog("tui-sandbox.neovim.prepareNewTestDirectory")
-
-export async function prepareNewTestDirectory(config: TestServerConfig): Promise<TestDirectory> {
-  try {
-    // if the directory does not exist, create it
-    await access(config.directories.testEnvironmentPath)
-  } catch {
-    log(`Creating testEnvironmentPath directory at ${config.directories.testEnvironmentPath}`)
-    await mkdir(config.directories.testEnvironmentPath, { recursive: true })
-  }
-
-  await removeTestDirectories(config.directories.testEnvironmentPath)
-  const testDirectory = await createTempDir(config)
-  return testDirectory
-}

package/src/server/applications/terminal/TerminalTestApplication.ts

@@ -1,101 +0,0 @@
-import assert from "assert"
-import { exec } from "child_process"
-import EventEmitter from "events"
-import { join } from "path"
-import { debuglog } from "util"
-import type { TestDirectory, TestEnvironmentCommonEnvironmentVariables } from "../../types.js"
-import { DisposableSingleApplication } from "../../utilities/DisposableSingleApplication.js"
-import { TerminalApplication } from "../../utilities/TerminalApplication.js"
-import type { StdoutOrStderrMessage, TerminalDimensions } from "../neovim/NeovimApplication.js"
-
-export type { StdoutOrStderrMessage }
-
-const log = debuglog("tui-sandbox.terminal.TerminalTestApplication")
-
-type ResettableState = {
-  testDirectory: TestDirectory
-}
-
-export type StartTerminalGenericArguments = {
-  commandToRun: string[]
-  additionalEnvironmentVariables?: Record<string, string> | undefined
-}
-
-export default class TerminalTestApplication implements AsyncDisposable {
-  public state: ResettableState | undefined
-  public readonly events: EventEmitter
-
-  public constructor(public readonly application: DisposableSingleApplication = new DisposableSingleApplication()) {
-    this.events = new EventEmitter()
-  }
-
-  public async startNextAndKillCurrent(
-    testDirectory: TestDirectory,
-    startArgs: StartTerminalGenericArguments,
-    terminalDimensions: TerminalDimensions
-  ): Promise<void> {
-    await this[Symbol.asyncDispose]()
-    assert(
-      this.state === undefined,
-      "TerminalTestApplication state should be undefined after disposing so that no previous state is reused."
-    )
-
-    const command = startArgs.commandToRun[0]
-    assert(command, "No command to run was provided.")
-    // TODO could check if the command is executable
-    const terminalArguments = startArgs.commandToRun.slice(1)
-
-    const stdout = this.events
-
-    await this.application.startNextAndKillCurrent(async () => {
-      const env = this.getEnvironmentVariables(testDirectory, startArgs.additionalEnvironmentVariables)
-      return TerminalApplication.start({
-        command,
-        args: terminalArguments,
-
-        cwd: testDirectory.rootPathAbsolute,
-        env,
-        dimensions: terminalDimensions,
-
-        onStdoutOrStderr(data) {
-          data satisfies string
-          stdout.emit("stdout" satisfies StdoutOrStderrMessage, data)
-        },
-      })
-    })
-
-    const processId = this.application.processId()
-    assert(
-      processId !== undefined,
-      "TerminalApplication was started without a process ID. This is a bug - please open an issue."
-    )
-
-    this.state = { testDirectory }
-
-    log(`🚀 Started Terminal instance ${processId}`)
-  }
-
-  public getEnvironmentVariables(
-    testDirectory: TestDirectory,
-    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,
-      ...additionalEnvironmentVariables,
-    } satisfies TestEnvironmentCommonEnvironmentVariables
-  }
-
-  async [Symbol.asyncDispose](): Promise<void> {
-    await this.application[Symbol.asyncDispose]()
-
-    if (!this.state) return
-
-    exec(`rm -rf ${this.state.testDirectory.rootPathAbsolute}`)
-
-    this.state = undefined
-  }
-}

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

@@ -1,89 +0,0 @@
-import assert from "assert"
-import type { BlockingCommandInput } from "../../blockingCommandInputSchema.js"
-import type { BlockingShellCommandOutput, 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 { prepareNewTestDirectory } from "../neovim/prepareNewTestDirectory.js"
-import { executeBlockingShellCommand } from "./runBlockingShellCommand.js"
-import type { StartTerminalInput } from "./terminalRouter.js"
-import type { StdoutOrStderrMessage } from "./TerminalTestApplication.js"
-import TerminalTestApplication from "./TerminalTestApplication.js"
-
-const terminals = new Map<TabId["tabId"], TerminalTestApplication>()
-const resources: Lazy<AsyncDisposableStack> = new Lazy(() => {
-  return new AsyncDisposableStack()
-})
-
-export async function start(
-  { tabId, startTerminalArguments }: StartTerminalInput,
-  config: TestServerConfig
-): Promise<TestDirectory> {
-  const app = terminals.get(tabId.tabId)
-  assert(app, `Terminal with tabId ${tabId.tabId} not found.`)
-  const testDirectory = await prepareNewTestDirectory(config)
-  await app.startNextAndKillCurrent(
-    testDirectory,
-    {
-      commandToRun: startTerminalArguments.commandToRun,
-      additionalEnvironmentVariables: startTerminalArguments.additionalEnvironmentVariables,
-    },
-    startTerminalArguments.terminalDimensions
-  )
-
-  return testDirectory
-}
-
-export async function initializeStdout(
-  options: { client: TabId },
-  signal: AbortSignal | undefined
-): Promise<AsyncGenerator<string, void, unknown>> {
-  const tabId = options.client.tabId
-  const app = terminals.get(tabId) ?? new TerminalTestApplication()
-  if (terminals.get(tabId) === undefined) {
-    terminals.set(tabId, app)
-    resources.get().use(app)
-  }
-
-  const stdout = convertEventEmitterToAsyncGenerator(app.events, "stdout" satisfies StdoutOrStderrMessage)
-  signal?.addEventListener("abort", () => {
-    void app[Symbol.asyncDispose]().finally(() => {
-      terminals.delete(tabId)
-    })
-  })
-
-  return stdout
-}
-
-export async function sendStdin(options: { tabId: TabId; data: string }): Promise<void> {
-  const tabId = options.tabId.tabId
-  const app = terminals.get(tabId)
-  assert(app !== undefined, `Terminal instance for tabId not found - cannot send stdin. Maybe it's not started yet?`)
-  assert(
-    app.application,
-    `Terminal application not found for client id ${options.tabId.tabId}. Maybe it's not started yet?`
-  )
-
-  await app.application.write(options.data)
-}
-
-export async function runBlockingShellCommand(
-  signal: AbortSignal | undefined,
-  input: BlockingCommandInput,
-  allowFailure: boolean
-): Promise<BlockingShellCommandOutput> {
-  const tabId = input.tabId.tabId
-  const app = terminals.get(tabId)
-  assert(
-    app !== undefined,
-    `Terminal instance for tabId ${input.tabId.tabId} not found - cannot send stdin. Maybe it's not started yet?`
-  )
-  assert(app.application, `Terminal application not found for tabId ${input.tabId.tabId}. Maybe it's not started yet?`)
-
-  const testDirectory = app.state?.testDirectory
-  assert(testDirectory, `Test directory not found for client id ${input.tabId.tabId}. Maybe neovim's not started yet?`)
-
-  const env = app.getEnvironmentVariables(testDirectory, input.envOverrides)
-  return executeBlockingShellCommand(testDirectory, input, signal, allowFailure, env)
-}

package/src/server/applications/terminal/runBlockingShellCommand.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { getCwd } from "./runBlockingShellCommand.js"
-
-describe("getCwd", () => {
-  it("prefers cwdRelative if it is defined", () => {
-    // in many cases this is what the user wants to do, so prefer that
-
-    const result = getCwd({
-      rootPathAbsolute: "/root-absolute",
-      cwdRelative: "test-cwd-relative",
-      cwdAbsolute: "/test-cwd",
-      home: "/test-home",
-    })
-    expect(result).toEqual("/root-absolute/test-cwd-relative")
-  })
-
-  it("falls back to cwd if cwdRelative is not defined", () => {
-    // this is used when the user wants to use absolute paths
-
-    const result = getCwd({
-      rootPathAbsolute: "/root-absolute",
-      cwdRelative: undefined,
-      cwdAbsolute: "/test-cwd",
-      home: "/test-home",
-    })
-    expect(result).toEqual("/test-cwd")
-  })
-
-  it("falls back to HOME if neither cwdRelative nor cwd are defined", () => {
-    // if the user doesn't specify anything, we default to the home directory
-    // because a directory must be present when running the command
-
-    const result = getCwd({
-      rootPathAbsolute: "/root-absolute",
-      cwdRelative: undefined,
-      cwdAbsolute: undefined,
-      home: "/test-home",
-    })
-    expect(result).toEqual("/test-home")
-  })
-})

package/src/server/applications/terminal/runBlockingShellCommand.ts

@@ -1,64 +0,0 @@
-import { exec } from "child_process"
-import { join } from "path"
-import util, { debuglog } from "util"
-import type { BlockingCommandInput } from "../../blockingCommandInputSchema.js"
-import type { BlockingShellCommandOutput, TestDirectory } from "../../types.js"
-
-const log = debuglog("tui-sandbox.terminal.runBlockingShellCommand")
-
-export async function executeBlockingShellCommand(
-  testDirectory: TestDirectory,
-  input: BlockingCommandInput,
-  signal: AbortSignal | undefined,
-  allowFailure: boolean,
-  env: NodeJS.ProcessEnv
-): Promise<BlockingShellCommandOutput> {
-  const execPromise = util.promisify(exec)
-
-  const cwd = getCwd({
-    rootPathAbsolute: testDirectory.rootPathAbsolute,
-    cwdRelative: input.cwdRelative,
-    cwdAbsolute: input.cwd,
-    home: testDirectory.rootPathAbsolute,
-  })
-
-  try {
-    const result = await execPromise(input.command, {
-      signal,
-      shell: input.shell,
-      uid: input.uid,
-      gid: input.gid,
-      cwd,
-      env,
-    })
-    log(
-      `Successfully ran shell blockingCommand (${input.command}) in cwd: '${cwd}' with stdout: ${result.stdout}, stderr: ${result.stderr}`
-    )
-    return {
-      type: "success",
-      stdout: result.stdout,
-      stderr: result.stderr,
-    } satisfies BlockingShellCommandOutput
-  } catch (e) {
-    console.warn(`Error running shell blockingCommand (${input.command})`, e)
-    if (allowFailure) {
-      return {
-        type: "failed",
-      }
-    }
-    throw new Error(`Error running shell blockingCommand (${input.command})`, { cause: e })
-  }
-}
-
-export type GetCwdArguments = {
-  rootPathAbsolute: string
-  cwdRelative: string | undefined
-  cwdAbsolute: string | undefined
-  home: string
-}
-export function getCwd(args: GetCwdArguments): string {
-  if (args.cwdRelative) {
-    return join(args.rootPathAbsolute, args.cwdRelative)
-  }
-  return args.cwdAbsolute ?? args.home
-}

package/src/server/applications/terminal/terminalRouter.ts

@@ -1,47 +0,0 @@
-import * as z from "zod"
-import { blockingCommandInputSchema } from "../../blockingCommandInputSchema.js"
-import { trpc } from "../../connection/trpc.js"
-import { serverTestDirectorySchema } from "../../types.js"
-import type { TestServerConfig } from "../../updateTestdirectorySchemaFile.js"
-import { tabIdSchema } from "../../utilities/tabId.js"
-import * as terminal from "./api.js"
-
-const startTerminalInputSchema = z.object({
-  tabId: tabIdSchema,
-  startTerminalArguments: z.object({
-    commandToRun: z.array(z.string()),
-    additionalEnvironmentVariables: z.record(z.string(), z.string()).optional(),
-    terminalDimensions: z.object({
-      cols: z.number(),
-      rows: z.number(),
-    }),
-  }),
-})
-export type StartTerminalInput = z.infer<typeof startTerminalInputSchema>
-
-// let trpc infer the type as that is what it is designed to do
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function createTerminalRouter(config: TestServerConfig) {
-  const terminalRouter = trpc.router({
-    onStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
-      return terminal.initializeStdout(options.input, options.signal)
-    }),
-
-    start: trpc.procedure
-      .input(startTerminalInputSchema)
-      .output(serverTestDirectorySchema)
-      .mutation(async options => {
-        return terminal.start(options.input, config)
-      }),
-
-    sendStdin: trpc.procedure.input(z.object({ tabId: tabIdSchema, data: z.string() })).mutation(options => {
-      return terminal.sendStdin(options.input)
-    }),
-
-    runBlockingShellCommand: trpc.procedure.input(blockingCommandInputSchema).mutation(async options => {
-      return terminal.runBlockingShellCommand(options.signal, options.input, options.input.allowFailure ?? false)
-    }),
-  })
-
-  return terminalRouter
-}

package/src/server/blockingCommandInputSchema.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { blockingCommandInputSchema, type BlockingCommandInput } from "./blockingCommandInputSchema.js"
-
-describe("blockingCommandInputSchema", () => {
-  it("allows either cwd or cwdRelative but not both", () => {
-    // It doesn't make sense to have two sources of truth for the cwd.
-    const fails = blockingCommandInputSchema.safeParse({
-      command: "command",
-      tabId: { tabId: "123" },
-      cwd: "cwd",
-      cwdRelative: "cwdRelative",
-    } satisfies Partial<BlockingCommandInput>)
-
-    expect(fails.error).toMatchInlineSnapshot(`
-      [ZodError: [
-        {
-          "code": "custom",
-          "path": [],
-          "message": "Both cwd and cwdRelative provided. Please provide either but not both at the same time."
-        }
-      ]]
-    `)
-  })
-})

package/src/server/blockingCommandInputSchema.ts

@@ -1,27 +0,0 @@
-import type { Except } from "type-fest"
-import * as z from "zod"
-import { tabIdSchema } from "./utilities/tabId.js"
-
-export const blockingCommandInputSchema = z
-  .object({
-    command: z.string(),
-    shell: z.string().optional(),
-    tabId: tabIdSchema,
-    allowFailure: z.boolean().optional(),
-
-    // absolute cwd
-    cwd: z.string().optional(),
-    cwdRelative: z.string().optional(),
-    envOverrides: z.record(z.string(), z.string()).optional(),
-    uid: z.number().optional(),
-    gid: z.number().optional(),
-  })
-  .refine(
-    data =>
-      // disallow both cwd and cwdRelative
-      !(data.cwd && data.cwdRelative),
-    { message: "Both cwd and cwdRelative provided. Please provide either but not both at the same time." }
-  )
-
-export type BlockingCommandClientInput = Except<BlockingCommandInput, "tabId">
-export type BlockingCommandInput = z.infer<typeof blockingCommandInputSchema>

package/src/server/config.test.ts

@@ -1,7 +0,0 @@
-import { createDefaultConfig } from "./config.js"
-import { testServerConfigSchema } from "./updateTestdirectorySchemaFile.js"
-
-it("is possible not to customize anything", () => {
-  const defaultConfig = createDefaultConfig(process.cwd(), process.env)
-  testServerConfigSchema.parse(defaultConfig)
-})

package/src/server/config.ts

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

package/src/server/connection/trpc.ts

@@ -1,3 +0,0 @@
-import { initTRPC } from "@trpc/server"
-
-export const trpc = initTRPC.context<object>().create()