@tui-sandbox/library 9.1.10 → 9.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tui-sandbox/library",
-  "version": "9.1.10",
+  "version": "9.2.0",
   "license": "MIT",
   "type": "module",
   "bin": {

package/src/browser/neovim-client.ts

@@ -61,6 +61,7 @@ declare global {
 
 export type GenericTerminalBrowserApi = {
   dir: TestDirectory
+  runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput>
 }
 
 /** Entrypoint for the test runner (cypress) */
@@ -69,5 +70,10 @@ window.startTerminalApplication = async function (
 ): Promise<GenericTerminalBrowserApi> {
   const terminal = terminalClient.get()
   const testDirectory = await terminal.startTerminalApplication(args)
-  return { dir: testDirectory }
+  return {
+    dir: testDirectory,
+    runBlockingShellCommand(input) {
+      return terminal.runBlockingShellCommand(input)
+    },
+  }
 }

package/src/client/terminal-terminal-client.ts

@@ -1,9 +1,9 @@
 import { createTRPCClient, httpBatchLink, splitLink, unstable_httpSubscriptionLink } from "@trpc/client"
 import type { Terminal } from "@xterm/xterm"
 import "@xterm/xterm/css/xterm.css"
-import type { AppRouter } from "../server/server.js"
+import type { AppRouter, BlockingCommandClientInput } from "../server/server.js"
 import type { StartTerminalGenericArguments } from "../server/terminal/TerminalTestApplication.js"
-import type { TestDirectory } from "../server/types.js"
+import type { BlockingShellCommandOutput, TestDirectory } from "../server/types.js"
 import "./style.css"
 import { getTabId, startTerminal } from "./websocket-client.js"
 
@@ -83,4 +83,9 @@ export class TerminalTerminalClient {
 
     return testDirectory
   }
+
+  public async runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput> {
+    await this.ready
+    return this.trpc.terminal.runBlockingShellCommand.mutate({ ...input, tabId: this.tabId })
+  }
 }

package/src/server/cypress-support/contents.ts

@@ -35,6 +35,10 @@ export type TerminalTestApplicationContext = {
    * keystrokes as input. Requires the application to be running. */
   typeIntoTerminal(text: string, options?: Partial<Cypress.TypeOptions>): void
 
+  /** Runs a shell command in a blocking manner, waiting for the command to
+   * finish before returning. Requires the terminal to be running. */
+  runBlockingShellCommand(input: BlockingCommandClientInput): Cypress.Chainable<BlockingShellCommandOutput>
+
   /** The test directory, providing type-safe access to its file and directory structure */
   dir: TestDirectory<MyTestDirectory>
 }
@@ -168,6 +172,7 @@ afterEach(async () => {
     await Promise.race([timeout, testNeovim.runExCommand({ command: "messages" })])
   } finally {
     clearTimeout(timeoutId) // Ensure the timeout is cleared
+    testNeovim = undefined
   }
 })
 `

package/src/server/neovim/index.ts

@@ -1,10 +1,9 @@
 import assert from "assert"
-import { exec } from "child_process"
 import "core-js/proposals/async-explicit-resource-management.js"
 import { access } from "fs/promises"
 import path from "path"
-import util from "util"
 import type { BlockingCommandInput, ExCommandInput, LuaCodeInput } from "../server.js"
+import { executeBlockingShellCommand } from "../terminal/runBlockingShellCommand.js"
 import type {
   BlockingShellCommandOutput,
   RunExCommandOutput,
@@ -124,36 +123,8 @@ export async function runBlockingShellCommand(
   const testDirectory = neovim.state?.testDirectory
   assert(testDirectory, `Test directory not found for client id ${input.tabId.tabId}. Maybe neovim's not started yet?`)
 
-  const execPromise = util.promisify(exec)
   const env = neovim.getEnvironmentVariables(testDirectory, input.envOverrides)
-  const processPromise = execPromise(input.command, {
-    signal: signal,
-    shell: input.shell,
-    uid: input.uid,
-    gid: input.gid,
-    cwd: input.cwd ?? env["HOME"],
-    env,
-  })
-
-  try {
-    const result = await processPromise
-    console.log(
-      `Successfully ran shell blockingCommand (${input.command}) 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 })
-  }
+  return executeBlockingShellCommand(input, signal, allowFailure, env)
 }
 
 export async function runLuaCode(options: LuaCodeInput): Promise<RunLuaCodeOutput> {

package/src/server/server.ts

@@ -72,6 +72,10 @@ export async function createAppRouter(config: DirectoriesConfig) {
       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)
+      }),
     }),
 
     neovim: trpc.router({

package/src/server/terminal/index.ts

@@ -2,10 +2,13 @@ import assert from "assert"
 import "core-js/proposals/async-explicit-resource-management.js"
 import type { TerminalDimensions } from "../neovim/NeovimApplication.js"
 import { prepareNewTestDirectory } from "../neovim/prepareNewTestDirectory.js"
+import type { BlockingCommandInput } from "../server.js"
+import type { BlockingShellCommandOutput } from "../types.js"
 import type { DirectoriesConfig } from "../updateTestdirectorySchemaFile.js"
 import { convertEventEmitterToAsyncGenerator } from "../utilities/generator.js"
 import { Lazy } from "../utilities/Lazy.js"
 import type { TabId } from "../utilities/tabId.js"
+import { executeBlockingShellCommand } from "./runBlockingShellCommand.js"
 import TerminalTestApplication from "./TerminalTestApplication.js"
 
 const terminals = new Map<TabId["tabId"], TerminalTestApplication>()
@@ -60,3 +63,23 @@ export async function sendStdin(options: { tabId: TabId; data: string }): Promis
 
   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 clientId not found - cannot send stdin. Maybe it's not started yet?`)
+  assert(
+    app.application,
+    `Terminal application not found for client id ${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(input, signal, allowFailure, env)
+}

package/src/server/terminal/runBlockingShellCommand.ts

@@ -0,0 +1,45 @@
+import { exec } from "child_process"
+import "core-js/proposals/async-explicit-resource-management.js"
+import util from "util"
+import type { BlockingCommandInput } from "../server.js"
+import type { BlockingShellCommandOutput } from "../types.js"
+
+export async function executeBlockingShellCommand(
+  input: BlockingCommandInput,
+  signal: AbortSignal | undefined,
+  allowFailure: boolean,
+  env: NodeJS.ProcessEnv
+): Promise<BlockingShellCommandOutput> {
+  const execPromise = util.promisify(exec)
+
+  const cwd = input.cwd ?? env["HOME"]
+
+  const processPromise = execPromise(input.command, {
+    signal: signal,
+    shell: input.shell,
+    uid: input.uid,
+    gid: input.gid,
+    cwd: cwd,
+    env,
+  })
+
+  try {
+    const result = await processPromise
+    console.log(
+      `Successfully ran shell blockingCommand (${input.command}) 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 })
+  }
+}