@tui-sandbox/library 9.0.1 → 9.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tui-sandbox/library",
-  "version": "9.0.1",
+  "version": "9.1.0",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -8,8 +8,8 @@
   },
   "dependencies": {
     "@catppuccin/palette": "1.7.1",
-    "@trpc/client": "11.0.0-rc.718",
-    "@trpc/server": "11.0.0-rc.718",
+    "@trpc/client": "11.0.0-rc.768",
+    "@trpc/server": "11.0.0-rc.768",
     "@xterm/addon-attach": "0.11.0",
     "@xterm/addon-fit": "0.10.0",
     "@xterm/xterm": "5.5.0",
@@ -20,21 +20,21 @@
     "express": "4.21.2",
     "neovim": "5.3.0",
     "node-pty": "1.0.0",
-    "prettier": "3.4.2",
+    "prettier": "3.5.1",
     "tsx": "4.19.2",
-    "type-fest": "4.33.0",
+    "type-fest": "4.34.1",
     "winston": "3.17.0",
-    "zod": "3.24.1"
+    "zod": "3.24.2"
   },
   "devDependencies": {
     "@runtyping/zod": "2.1.1",
     "@types/command-exists": "1.2.3",
     "@types/cors": "2.8.17",
     "@types/express": "5.0.0",
-    "@types/node": "22.10.10",
+    "@types/node": "22.13.4",
     "nodemon": "3.1.9",
-    "vite": "6.0.11",
-    "vitest": "3.0.4"
+    "vite": "6.1.0",
+    "vitest": "3.0.5"
   },
   "peerDependencies": {
     "cypress": "^13 || ^14",

package/src/browser/neovim-client.ts

@@ -1,5 +1,7 @@
-import { TerminalClient } from "../client/index.js"
+import { TerminalClient as NeovimTerminalClient } from "../client/index.js"
+import { TerminalTerminalClient } from "../client/terminal-terminal-client.js"
 import type { BlockingCommandClientInput, ExCommandClientInput, LuaCodeClientInput } from "../server/server.js"
+import type { StartTerminalGenericArguments } from "../server/terminal/TerminalTestApplication.js"
 import type {
   BlockingShellCommandOutput,
   RunExCommandOutput,
@@ -7,13 +9,16 @@ import type {
   StartNeovimGenericArguments,
   TestDirectory,
 } from "../server/types.js"
+import { Lazy } from "../server/utilities/Lazy.js"
 
 const app = document.querySelector<HTMLElement>("#app")
 if (!app) {
   throw new Error("No app element found")
 }
 
-const client = new TerminalClient(app)
+// limitation: right now only one client can be used in the same test
+const neovimClient = new Lazy(() => new NeovimTerminalClient(app))
+const terminalClient = new Lazy(() => new TerminalTerminalClient(app))
 
 export type GenericNeovimBrowserApi = {
   runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput>
@@ -24,7 +29,8 @@ export type GenericNeovimBrowserApi = {
 
 /** Entrypoint for the test runner (cypress) */
 window.startNeovim = async function (startArgs?: StartNeovimGenericArguments): Promise<GenericNeovimBrowserApi> {
-  const testDirectory = await client.startNeovim({
+  const neovim = neovimClient.get()
+  const testDirectory = await neovim.startNeovim({
     additionalEnvironmentVariables: startArgs?.additionalEnvironmentVariables,
     filename: startArgs?.filename ?? "initial-file.txt",
     startupScriptModifications: startArgs?.startupScriptModifications ?? [],
@@ -32,13 +38,13 @@ window.startNeovim = async function (startArgs?: StartNeovimGenericArguments): P
 
   const neovimBrowserApi: GenericNeovimBrowserApi = {
     runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput> {
-      return client.runBlockingShellCommand(input)
+      return neovim.runBlockingShellCommand(input)
     },
     runLuaCode(input) {
-      return client.runLuaCode(input)
+      return neovim.runLuaCode(input)
     },
     runExCommand(input) {
-      return client.runExCommand(input)
+      return neovim.runExCommand(input)
     },
     dir: testDirectory,
   }
@@ -49,5 +55,19 @@ window.startNeovim = async function (startArgs?: StartNeovimGenericArguments): P
 declare global {
   interface Window {
     startNeovim(startArguments?: StartNeovimGenericArguments): Promise<GenericNeovimBrowserApi>
+    startTerminalApplication(args: StartTerminalGenericArguments): Promise<GenericTerminalBrowserApi>
   }
 }
+
+export type GenericTerminalBrowserApi = {
+  dir: TestDirectory
+}
+
+/** Entrypoint for the test runner (cypress) */
+window.startTerminalApplication = async function (
+  args: StartTerminalGenericArguments
+): Promise<GenericTerminalBrowserApi> {
+  const terminal = terminalClient.get()
+  const testDirectory = await terminal.startTerminalApplication(args)
+  return { dir: testDirectory }
+}

package/src/client/index.ts

@@ -1,4 +1,5 @@
 // This is the public client api. Semantic versioning will be applied to this.
 
 export { rgbify } from "./color-utilities.js"
-export { TerminalClient } from "./terminal-client.js"
+export { NeovimTerminalClient as TerminalClient } from "./neovim-terminal-client.js"
+export { TerminalTerminalClient } from "./terminal-terminal-client.js"

package/src/client/{terminal-client.ts → neovim-terminal-client.ts}

@@ -19,7 +19,7 @@ import { getTabId, startTerminal } from "./websocket-client.js"
 
 /** Manages the terminal state in the browser as well as the (browser's)
  * connection to the server side terminal application api. */
-export class TerminalClient {
+export class NeovimTerminalClient {
   private readonly ready: Promise<void>
   private readonly tabId: { tabId: string }
   private readonly terminal: Terminal
@@ -59,7 +59,7 @@ export class TerminalClient {
     // start listening to Neovim stdout - this will take some (short) amount of
     // time to complete
     this.ready = new Promise<void>(resolve => {
-      console.log("Subscribing to Neovim stdout")
+      console.log("Subscribing to stdout")
       trpc.neovim.onStdout.subscribe(
         { client: tabId },
         {
@@ -70,7 +70,7 @@ export class TerminalClient {
             terminal.write(data)
           },
           onError(err: unknown) {
-            console.error(`Error from Neovim`, err)
+            console.error(`Error from the application`, err)
           },
         }
       )

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

@@ -0,0 +1,86 @@
+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 { StartTerminalGenericArguments } from "../server/terminal/TerminalTestApplication.js"
+import type { TestDirectory } from "../server/types.js"
+import "./style.css"
+import { getTabId, startTerminal } from "./websocket-client.js"
+
+/** Manages the terminal state in the browser as well as the (browser's)
+ * connection to the server side terminal application api. */
+export class TerminalTerminalClient {
+  private readonly ready: Promise<void>
+  private readonly tabId: { tabId: string }
+  private readonly terminal: Terminal
+  private readonly trpc: ReturnType<typeof createTRPCClient<AppRouter>>
+
+  constructor(app: HTMLElement) {
+    const trpc = createTRPCClient<AppRouter>({
+      links: [
+        splitLink({
+          condition: operation => operation.type === "subscription",
+          true: unstable_httpSubscriptionLink({
+            url: "/trpc",
+          }),
+          false: httpBatchLink({
+            url: "/trpc",
+          }),
+        }),
+      ],
+    })
+    this.trpc = trpc
+
+    this.tabId = getTabId()
+    const tabId = this.tabId
+
+    const terminal = startTerminal(app, {
+      onMouseEvent(data: string) {
+        void trpc.terminal.sendStdin.mutate({ tabId, data }).catch((error: unknown) => {
+          console.error(`Error sending mouse event`, error)
+        })
+      },
+      onKeyPress(event) {
+        void trpc.terminal.sendStdin.mutate({ tabId, data: event.key })
+      },
+    })
+    this.terminal = terminal
+
+    // start listening to Neovim stdout - this will take some (short) amount of
+    // time to complete
+    this.ready = new Promise<void>(resolve => {
+      console.log("Subscribing to stdout")
+      trpc.terminal.onStdout.subscribe(
+        { client: tabId },
+        {
+          onStarted() {
+            resolve()
+          },
+          onData(data: string) {
+            terminal.write(data)
+          },
+          onError(err: unknown) {
+            console.error(`Error from the application`, err)
+          },
+        }
+      )
+    })
+  }
+
+  public async startTerminalApplication(args: StartTerminalGenericArguments): Promise<TestDirectory> {
+    await this.ready
+    const testDirectory = await this.trpc.terminal.start.mutate({
+      tabId: this.tabId,
+      startTerminalArguments: {
+        additionalEnvironmentVariables: args.additionalEnvironmentVariables,
+        commandToRun: args.commandToRun,
+        terminalDimensions: {
+          cols: this.terminal.cols,
+          rows: this.terminal.rows,
+        },
+      },
+    })
+
+    return testDirectory
+  }
+}

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

@@ -10,7 +10,10 @@ export async function createCypressSupportFileContents(): Promise<string> {
 //
 // This file is autogenerated by tui-sandbox. Do not edit it directly.
 //
-import type { GenericNeovimBrowserApi } from "@tui-sandbox/library/dist/src/browser/neovim-client"
+import type {
+  GenericNeovimBrowserApi,
+  GenericTerminalBrowserApi,
+} from "@tui-sandbox/library/dist/src/browser/neovim-client"
 import type {
   BlockingCommandClientInput,
   ExCommandClientInput,
@@ -23,9 +26,19 @@ import type {
   StartNeovimGenericArguments,
   TestDirectory,
 } from "@tui-sandbox/library/dist/src/server/types"
+import type { StartTerminalGenericArguments } from "@tui-sandbox/library/src/server/terminal/TerminalTestApplication"
 import type { OverrideProperties } from "type-fest"
 import type { MyTestDirectory, MyTestDirectoryFile } from "../../MyTestDirectory"
 
+export type TerminalTestApplicationContext = {
+  /** Types text into the terminal, making the terminal application receive the
+   * keystrokes as input. Requires the application to be running. */
+  typeIntoTerminal(text: string, options?: Partial<Cypress.TypeOptions>): void
+
+  /** The test directory, providing type-safe access to its file and directory structure */
+  dir: TestDirectory<MyTestDirectory>
+}
+
 /** The api that can be used in tests after a Neovim instance has been started. */
 export type NeovimContext = {
   /** Types text into the terminal, making the terminal application receive
@@ -93,6 +106,14 @@ Cypress.Commands.add("startNeovim", (startArguments?: MyStartNeovimServerArgumen
   })
 })
 
+Cypress.Commands.add("startTerminalApplication", (args: StartTerminalGenericArguments) => {
+  cy.window().then(async win => {
+    const api: GenericTerminalBrowserApi = await win.startTerminalApplication(args)
+
+    return api
+  })
+})
+
 Cypress.Commands.add("typeIntoTerminal", (text: string, options?: Partial<Cypress.TypeOptions>) => {
   // the syntax for keys is described here:
   // https://docs.cypress.io/api/commands/type
@@ -112,6 +133,7 @@ declare global {
   namespace Cypress {
     interface Chainable {
       startNeovim(args?: MyStartNeovimServerArguments): Chainable<NeovimContext>
+      startTerminalApplication(args: StartTerminalGenericArguments): Chainable<TerminalTestApplicationContext>
 
       /** Types text into the terminal, making the terminal application receive
        * the keystrokes as input. Requires neovim to be running. */

package/src/server/dirtree/index.test.ts

@@ -39,6 +39,7 @@ describe("dirtree", () => {
         name: z.literal("test-environment/"),
         type: z.literal("directory"),
         contents: z.object({
+          ".bashrc": z.object({ name: z.literal(".bashrc"), type: z.literal("file") }),
           ".config": z.object({
             name: z.literal(".config/"),
             type: z.literal("directory"),
@@ -127,6 +128,7 @@ describe("dirtree", () => {
       export type MyDirectoryTree = MyDirectoryTreeContentsSchemaType["contents"]
 
       export const testDirectoryFiles = z.enum([
+        ".bashrc",
         ".config/.gitkeep",
         ".config/nvim/init.lua",
         ".config/nvim/prepare.lua",

package/src/server/neovim/NeovimApplication.ts

@@ -5,7 +5,7 @@ import { access } from "fs/promises"
 import type { NeovimClient as NeovimApiClient } from "neovim"
 import { tmpdir } from "os"
 import path, { join } from "path"
-import type { TestDirectory } from "../types.js"
+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"
@@ -77,7 +77,7 @@ type ResettableState = {
   client: Lazy<Promise<NeovimApiClient>>
 }
 
-export class NeovimApplication {
+export class NeovimApplication implements AsyncDisposable {
   public state: ResettableState | undefined
   public readonly events: EventEmitter
 
@@ -190,7 +190,7 @@ export class NeovimApplication {
       XDG_DATA_HOME: join(testDirectory.testEnvironmentPath, ".repro", "data"),
 
       ...additionalEnvironmentVariables,
-    }
+    } satisfies TestEnvironmentCommonEnvironmentVariables
   }
 
   async [Symbol.asyncDispose](): Promise<void> {

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

@@ -13,12 +13,12 @@ class TempDirectory implements Disposable {
 
   public static create(): TempDirectory {
     const tmp = fs.mkdtempSync("test-temp-dir-" satisfies TestTempDirPrefix)
-    return new TempDirectory(tmp)
+    const absolutePath = nodePath.resolve(tmp)
+    return new TempDirectory(absolutePath)
   }
 
   [Symbol.dispose](): void {
-    // eslint-disable-next-line no-empty-function
-    fs.rm(this.path, { recursive: true }, () => {})
+    fs.rmdirSync(this.path, { recursive: true, maxRetries: 5 })
   }
 }
 
@@ -32,6 +32,6 @@ it("should create a temp dir with no contents", async () => {
 
   expect(result.contents).toEqual({})
   expect(result.testEnvironmentPath).toEqual(dir.path)
-  expect(result.testEnvironmentPath.startsWith("test-temp-dir-" satisfies TestTempDirPrefix)).toBeTruthy()
-  expect(result.testEnvironmentPathRelative.startsWith("testdirs" satisfies TestDirsPath)).toBeTruthy()
+  expect(result.testEnvironmentPath.includes("test-temp-dir-" satisfies TestTempDirPrefix)).toBeTruthy()
+  expect(result.testEnvironmentPathRelative.includes("testdirs" satisfies TestDirsPath)).toBeTruthy()
 })

package/src/server/server.ts

@@ -4,6 +4,7 @@ import type { Except } from "type-fest"
 import { z } from "zod"
 import { trpc } from "./connection/trpc.js"
 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"
@@ -45,6 +46,39 @@ export async function createAppRouter(config: DirectoriesConfig) {
   }
 
   const appRouter = trpc.router({
+    terminal: trpc.router({
+      onStdout: trpc.procedure.input(z.object({ client: tabIdSchema })).subscription(options => {
+        return terminal.initializeStdout(options.input, options.signal, config.testEnvironmentPath)
+      }),
+
+      start: trpc.procedure
+        .input(
+          z.object({
+            tabId: tabIdSchema,
+            startTerminalArguments: z.object({
+              commandToRun: z.array(z.string()),
+              additionalEnvironmentVariables: z.record(z.string()).optional(),
+              terminalDimensions: z.object({
+                cols: z.number(),
+                rows: z.number(),
+              }),
+            }),
+          })
+        )
+        .mutation(options => {
+          return terminal.start(
+            options.input.startTerminalArguments.terminalDimensions,
+            options.input.startTerminalArguments.commandToRun,
+            options.input.tabId,
+            config
+          )
+        }),
+
+      sendStdin: trpc.procedure.input(z.object({ tabId: tabIdSchema, data: z.string() })).mutation(options => {
+        return terminal.sendStdin(options.input)
+      }),
+    }),
+
     neovim: trpc.router({
       start: trpc.procedure
         .input(

package/src/server/terminal/TerminalTestApplication.ts

@@ -0,0 +1,98 @@
+import assert from "assert"
+import { exec } from "child_process"
+import EventEmitter from "events"
+import { join } from "path"
+import type { StdoutOrStderrMessage, TerminalDimensions } from "../neovim/NeovimApplication.js"
+import type { TestDirectory, TestEnvironmentCommonEnvironmentVariables } from "../types.js"
+import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication.js"
+import { TerminalApplication } from "../utilities/TerminalApplication.js"
+
+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(
+    private readonly testEnvironmentPath: string,
+    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: this.testEnvironmentPath,
+        env: 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 }
+
+    console.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"),
+      ...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/terminal/index.ts

@@ -0,0 +1,62 @@
+import assert from "assert"
+import "core-js/proposals/async-explicit-resource-management.js"
+import { prepareNewTestDirectory } from "../neovim/index.js"
+import type { TerminalDimensions } from "../neovim/NeovimApplication.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 TerminalTestApplication from "./TerminalTestApplication.js"
+
+const terminals = new Map<TabId["tabId"], TerminalTestApplication>()
+const resources: Lazy<AsyncDisposableStack> = new Lazy(() => {
+  return new AsyncDisposableStack()
+})
+
+export async function start(
+  terminalDimensions: TerminalDimensions,
+  commandToRun: string[],
+  tabId: TabId,
+  config: DirectoriesConfig
+): Promise<void> {
+  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 }, terminalDimensions)
+}
+
+export async function initializeStdout(
+  options: { client: TabId },
+  signal: AbortSignal | undefined,
+  testEnvironmentPath: string
+): Promise<AsyncGenerator<string, void, unknown>> {
+  const tabId = options.client.tabId
+  const app = terminals.get(tabId) ?? new TerminalTestApplication(testEnvironmentPath)
+  if (terminals.get(tabId) === undefined) {
+    terminals.set(tabId, app)
+    resources.get().adopt(app, async a => {
+      await a[Symbol.asyncDispose]()
+    })
+  }
+
+  const stdout = convertEventEmitterToAsyncGenerator(app.events, "stdout")
+  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 clientId 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)
+}

package/src/server/types.ts

@@ -31,6 +31,19 @@ export type TestDirectory<TContents extends object = object> = {
   contents: TContents
 }
 
+export type TestEnvironmentCommonEnvironmentVariables = {
+  HOME: string
+
+  // this is needed so that the application being tested can load its
+  // configuration, emulating a common setup real users have
+  XDG_CONFIG_HOME: string
+
+  // the data directory is where the application stores its data. To prevent
+  // downloading a new set of plugins/whatever for each test, share the data
+  // directory.
+  XDG_DATA_HOME: string
+}
+
 export type { StartNeovimGenericArguments } from "../server/neovim/NeovimApplication.js"
 
 export type BlockingShellCommandOutput =

package/src/server/utilities/TerminalApplication.ts

@@ -18,7 +18,8 @@ export class TerminalApplication implements StartableApplication {
   private constructor(
     private readonly subProcess: IPty,
     public readonly onStdoutOrStderr: (data: string) => void,
-    public readonly untilExit: Promise<ExitInfo>
+    public readonly untilExit: Promise<ExitInfo>,
+    public readonly name: string
   ) {
     this.processId = subProcess.pid
 
@@ -30,12 +31,11 @@ export class TerminalApplication implements StartableApplication {
 
     this.logger.debug(`started`)
 
-    subProcess.onData(this.onStdoutOrStderr)
-
     subProcess.onExit(({ exitCode, signal }) => {
-      this.logger.debug(
-        `Child process ${this.processId} exited with code ${String(exitCode)} and signal ${String(signal)}`
-      )
+      signal satisfies number | undefined
+      const msg = `Child process ${this.processId} (${this.name}) exited with code ${String(exitCode)} and signal ${String(signal)}`
+      this.onStdoutOrStderr(msg)
+      this.logger.debug(msg)
     })
   }
 
@@ -55,7 +55,8 @@ export class TerminalApplication implements StartableApplication {
     env?: NodeJS.ProcessEnv
     dimensions: ITerminalDimensions
   }): TerminalApplication {
-    console.log(`Starting '${command} ${args.join(" ")}' in cwd '${cwd}'`)
+    console.log(`Starting '${command}' with args '${args.join(" ")}' in cwd '${cwd}'`)
+
     const ptyProcess = pty.spawn(command, args, {
       name: "xterm-color",
       cwd,
@@ -63,6 +64,7 @@ export class TerminalApplication implements StartableApplication {
       cols: dimensions.cols,
       rows: dimensions.rows,
     })
+    ptyProcess.onData(onStdoutOrStderr)
     ptyProcess.onExit(({ exitCode, signal }) => {
       console.log(`Child process exited with code ${exitCode} and signal ${signal}`)
     })
@@ -79,7 +81,7 @@ export class TerminalApplication implements StartableApplication {
       })
     })
 
-    return new TerminalApplication(ptyProcess, onStdoutOrStderr, untilExit)
+    return new TerminalApplication(ptyProcess, onStdoutOrStderr, untilExit, ptyProcess.process satisfies string)
   }
 
   /** Write to the terminal's stdin. */