@tui-sandbox/library 9.1.9 → 9.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tui-sandbox/library",
-  "version": "9.1.9",
+  "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

@@ -7,7 +7,6 @@ import * as neovim from "./neovim/index.js"
 import * as terminal from "./terminal/index.js"
 import { TestServer } from "./TestServer.js"
 import type { DirectoriesConfig, TestServerConfig } from "./updateTestdirectorySchemaFile.js"
-import { applicationAvailable } from "./utilities/applicationAvailable.js"
 import { tabIdSchema } from "./utilities/tabId.js"
 
 const blockingCommandInputSchema = z.object({
@@ -41,10 +40,6 @@ export type ExCommandInput = z.infer<typeof exCommandInputSchema>
 /** @private */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export async function createAppRouter(config: DirectoriesConfig) {
-  if (!(await applicationAvailable("nvim"))) {
-    throw new Error("Neovim is not installed. Please install Neovim (nvim).")
-  }
-
   const appRouter = trpc.router({
     terminal: trpc.router({
       onStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
@@ -77,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({
@@ -136,23 +135,27 @@ export type AppRouter = Awaited<ReturnType<typeof createAppRouter>>
 export type RouterInput = inferRouterInputs<AppRouter>
 
 export async function startTestServer(config: TestServerConfig): Promise<TestServer> {
-  const testServer = new TestServer({
-    port: config.port,
-  })
-  const appRouter = await createAppRouter(config.directories)
-
-  const neovimTask: Promise<void> = neovim
-    .installDependencies(config.directories.testEnvironmentPath, config.directories)
-    .catch((err: unknown) => {
-      console.error("Error installing neovim dependencies", err)
+  try {
+    const testServer = new TestServer({
+      port: config.port,
     })
+    const appRouter = await createAppRouter(config.directories)
+
+    const neovimTask: Promise<void> = neovim
+      .installDependencies(config.directories.testEnvironmentPath, config.directories)
+      .catch((err: unknown) => {
+        console.error("Error installing neovim dependencies", err)
+        // suppress the error because neovim is optional - other applications
+        // can still be tested
+      })
+
+    const startServerTask = testServer.startAndRun(appRouter)
 
-  const startServerTask = testServer.startAndRun(appRouter)
+    await Promise.all([neovimTask, startServerTask])
 
-  await Promise.all([neovimTask, startServerTask]).catch((err: unknown) => {
+    return testServer
+  } catch (err: unknown) {
     console.error("Error starting test server", err)
     throw err
-  })
-
-  return testServer
+  }
 }

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 })
+  }
+}

package/dist/src/server/server.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/server/server.test.js

@@ -1,24 +0,0 @@
-import { createAppRouter } from "./server.js";
-import { applicationAvailable } from "./utilities/applicationAvailable.js";
-vi.mock("./utilities/applicationAvailable");
-const mocked = {
-    applicationAvailable: vi.mocked(applicationAvailable),
-};
-describe("Neovim server", () => {
-    it("complains when neovim is not installed", async () => {
-        await expect(createAppRouter({
-            outputFilePath: "outputFilePath",
-            testEnvironmentPath: "testEnvironmentPath",
-        })).rejects.toThrow("Neovim is not installed. Please install Neovim (nvim).");
-        expect(mocked.applicationAvailable).toHaveBeenCalledWith("nvim");
-    });
-    it("creates a router when neovim is installed", async () => {
-        mocked.applicationAvailable.mockResolvedValue("nvim");
-        await expect(createAppRouter({
-            outputFilePath: "outputFilePath",
-            testEnvironmentPath: "testEnvironmentPath",
-        })).resolves.toBeDefined();
-        expect(mocked.applicationAvailable).toHaveBeenCalledWith("nvim");
-    });
-});
-//# sourceMappingURL=server.test.js.map

package/dist/src/server/server.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.test.js","sourceRoot":"","sources":["../../../src/server/server.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAA;AAE1E,EAAE,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAA;AAE3C,MAAM,MAAM,GAAG;IACb,oBAAoB,EAAE,EAAE,CAAC,MAAM,CAAC,oBAAoB,CAAC;CACtD,CAAA;AAED,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,wCAAwC,EAAE,KAAK,IAAI,EAAE;QACtD,MAAM,MAAM,CACV,eAAe,CAAC;YACd,cAAc,EAAE,gBAAgB;YAChC,mBAAmB,EAAE,qBAAqB;SAC3C,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,wDAAwD,CAAC,CAAA;QAE3E,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAA;IAClE,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,2CAA2C,EAAE,KAAK,IAAI,EAAE;QACzD,MAAM,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAA;QAErD,MAAM,MAAM,CACV,eAAe,CAAC;YACd,cAAc,EAAE,gBAAgB;YAChC,mBAAmB,EAAE,qBAAqB;SAC3C,CAAC,CACH,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAA;QAExB,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAA;IAClE,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/src/server/server.test.ts

@@ -1,34 +0,0 @@
-import { createAppRouter } from "./server.js"
-import { applicationAvailable } from "./utilities/applicationAvailable.js"
-
-vi.mock("./utilities/applicationAvailable")
-
-const mocked = {
-  applicationAvailable: vi.mocked(applicationAvailable),
-}
-
-describe("Neovim server", () => {
-  it("complains when neovim is not installed", async () => {
-    await expect(
-      createAppRouter({
-        outputFilePath: "outputFilePath",
-        testEnvironmentPath: "testEnvironmentPath",
-      })
-    ).rejects.toThrow("Neovim is not installed. Please install Neovim (nvim).")
-
-    expect(mocked.applicationAvailable).toHaveBeenCalledWith("nvim")
-  })
-
-  it("creates a router when neovim is installed", async () => {
-    mocked.applicationAvailable.mockResolvedValue("nvim")
-
-    await expect(
-      createAppRouter({
-        outputFilePath: "outputFilePath",
-        testEnvironmentPath: "testEnvironmentPath",
-      })
-    ).resolves.toBeDefined()
-
-    expect(mocked.applicationAvailable).toHaveBeenCalledWith("nvim")
-  })
-})