npm - @tui-sandbox/library - Versions diffs - 6.0.2 → 7.0.0 - Mend

@tui-sandbox/library 6.0.2 → 7.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

package/CHANGELOG.md +18 -0
package/dist/browser/assets/{index-DJEG76in.js → index-Bup5cvb2.js} +3 -3
package/dist/browser/index.html +1 -1
package/dist/src/browser/neovim-client.d.ts +3 -1
package/dist/src/browser/neovim-client.js +5 -2
package/dist/src/client/index.d.ts +1 -1
package/dist/src/client/index.js +1 -1
package/dist/src/client/terminal-client.d.ts +15 -0
package/dist/src/client/{neovim-client.js → terminal-client.js} +10 -1
package/dist/src/server/cypress-support/contents.js +19 -1
package/dist/src/server/cypress-support/contents.test.js +19 -1
package/dist/src/server/cypress-support/createCypressSupportFile.js +2 -1
package/dist/src/server/neovim/NeovimApplication.d.ts +10 -1
package/dist/src/server/neovim/NeovimApplication.js +15 -12
package/dist/src/server/neovim/environment/createTempDir.test.js +2 -4
package/dist/src/server/neovim/index.d.ts +4 -1
package/dist/src/server/neovim/index.js +34 -0
package/dist/src/server/server.d.ts +54 -4
package/dist/src/server/server.js +13 -72
package/dist/src/server/types.d.ts +7 -0
package/dist/tsconfig.tsbuildinfo +1 -1
package/package.json +2 -2
package/src/browser/neovim-client.ts +11 -3
package/src/client/index.ts +1 -1
package/src/client/{neovim-client.ts → terminal-client.ts} +13 -3
package/src/server/cypress-support/contents.test.ts +19 -1
package/src/server/cypress-support/contents.ts +19 -1
package/src/server/cypress-support/createCypressSupportFile.ts +2 -1
package/src/server/neovim/NeovimApplication.ts +22 -15
package/src/server/neovim/environment/createTempDir.test.ts +1 -1
package/src/server/neovim/index.ts +46 -1
package/src/server/server.ts +18 -6
package/src/server/types.ts +12 -0
package/dist/src/client/neovim-client.d.ts +0 -11

package/dist/browser/index.html CHANGED Viewed

@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <title>tui-sandbox integration tests</title>
-    <script type="module" crossorigin src="/assets/index-DJEG76in.js"></script>
+    <script type="module" crossorigin src="/assets/index-Bup5cvb2.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Bf37MeF1.css">
   </head>
   <body>

package/dist/src/browser/neovim-client.d.ts CHANGED Viewed

@@ -1,6 +1,8 @@
-import type { StartNeovimGenericArguments, TestDirectory } from "../server/types.js";
+import type { BlockingCommandClientInput } from "../server/server.js";
+import type { BlockingShellCommandOutput, StartNeovimGenericArguments, TestDirectory } from "../server/types.js";
 declare global {
     interface Window {
         startNeovim(startArguments?: StartNeovimGenericArguments): Promise<TestDirectory>;
+        runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput>;
     }
 }

package/dist/src/browser/neovim-client.js CHANGED Viewed

@@ -1,9 +1,9 @@
-import { NeovimClient } from "../client/index.js";
+import { TerminalClient } from "../client/index.js";
 const app = document.querySelector("#app");
 if (!app) {
     throw new Error("No app element found");
 }
-const client = new NeovimClient(app);
+const client = new TerminalClient(app);
 /** Entrypoint for the test runner (cypress) */
 window.startNeovim = async function (startArgs) {
     const testDirectory = await client.startNeovim({
@@ -13,3 +13,6 @@ window.startNeovim = async function (startArgs) {
     });
     return testDirectory;
 };
+window.runBlockingShellCommand = async function (input) {
+    return client.runBlockingShellCommand(input);
+};

package/dist/src/client/index.d.ts CHANGED Viewed

@@ -1,2 +1,2 @@
 export { rgbify } from "./color-utilities.js";
-export { NeovimClient } from "./neovim-client.js";
+export { TerminalClient } from "./terminal-client.js";

package/dist/src/client/index.js CHANGED Viewed

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

package/dist/src/client/terminal-client.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import "@xterm/xterm/css/xterm.css";
+import type { BlockingCommandClientInput } from "../server/server.js";
+import type { BlockingShellCommandOutput, StartNeovimGenericArguments, TestDirectory } from "../server/types.js";
+import "./style.css";
+/** Manages the terminal state in the browser as well as the (browser's)
+ * connection to the server side terminal application api. */
+export declare class TerminalClient {
+    private readonly ready;
+    private readonly tabId;
+    private readonly terminal;
+    private readonly trpc;
+    constructor(app: HTMLElement);
+    startNeovim(args: StartNeovimGenericArguments): Promise<TestDirectory>;
+    runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput>;
+}

package/dist/src/client/{neovim-client.js → terminal-client.js} RENAMED Viewed

@@ -2,7 +2,9 @@ import { createTRPCClient, httpBatchLink, splitLink, unstable_httpSubscriptionLi
 import "@xterm/xterm/css/xterm.css";
 import "./style.css";
 import { getTabId, startTerminal } from "./websocket-client.js";
-export class NeovimClient {
+/** Manages the terminal state in the browser as well as the (browser's)
+ * connection to the server side terminal application api. */
+export class TerminalClient {
     ready;
     tabId;
     terminal;
@@ -68,4 +70,11 @@ export class NeovimClient {
         });
         return testDirectory;
     }
+    async runBlockingShellCommand(input) {
+        await this.ready;
+        return this.trpc.neovim.runBlockingShellCommand.mutate({
+            ...input,
+            tabId: this.tabId,
+        });
+    }
 }

package/dist/src/server/cypress-support/contents.js CHANGED Viewed

@@ -9,8 +9,12 @@ export async function createCypressSupportFileContents() {
 //
 // This file is autogenerated by tui-sandbox. Do not edit it directly.
 //
+import type { BlockingCommandClientInput } from "@tui-sandbox/library/dist/src/server/server"
+import type {
+  BlockingShellCommandOutput,
+  StartNeovimGenericArguments,
+} from "@tui-sandbox/library/dist/src/server/types"
 import type { OverrideProperties } from "type-fest"
-import type { StartNeovimGenericArguments } from "@tui-sandbox/library/dist/src/server/types"
 import type { MyTestDirectory, MyTestDirectoryFile } from "../../MyTestDirectory"
 export type NeovimContext = {
@@ -21,6 +25,7 @@ export type NeovimContext = {
 declare global {
   interface Window {
     startNeovim(startArguments?: MyStartNeovimServerArguments): Promise<NeovimContext>
+    runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput>
   }
 }
@@ -39,6 +44,12 @@ Cypress.Commands.add("startNeovim", (startArguments?: MyStartNeovimServerArgumen
   })
 })
+Cypress.Commands.add("runBlockingShellCommand", (input: BlockingCommandClientInput) => {
+  cy.window().then(async win => {
+    return await win.runBlockingShellCommand(input)
+  })
+})
 Cypress.Commands.add("typeIntoTerminal", (text: string, options?: Partial<Cypress.TypeOptions>) => {
   // the syntax for keys is described here:
   // https://docs.cypress.io/api/commands/type
@@ -56,7 +67,14 @@ declare global {
   namespace Cypress {
     interface Chainable {
       startNeovim(args?: MyStartNeovimServerArguments): Chainable<NeovimContext>
+      /** Types text into the terminal, making the terminal application receive
+       * the keystrokes as input. Requires neovim to be running. */
       typeIntoTerminal(text: string, options?: Partial<Cypress.TypeOptions>): Chainable<void>
+      /** Runs a shell command in a blocking manner, waiting for the command to
+       * finish before returning. Requires neovim to be running. */
+      runBlockingShellCommand(input: BlockingCommandClientInput): Chainable<BlockingShellCommandOutput>
     }
   }
 }

package/dist/src/server/cypress-support/contents.test.js CHANGED Viewed

@@ -6,7 +6,11 @@ it("should return the expected contents", async () => {
     //
     // This file is autogenerated by tui-sandbox. Do not edit it directly.
     //
-    import type { StartNeovimGenericArguments } from "@tui-sandbox/library/dist/src/server/types"
+    import type { BlockingCommandClientInput } from "@tui-sandbox/library/dist/src/server/server"
+    import type {
+      BlockingShellCommandOutput,
+      StartNeovimGenericArguments,
+    } from "@tui-sandbox/library/dist/src/server/types"
     import type { OverrideProperties } from "type-fest"
     import type { MyTestDirectory, MyTestDirectoryFile } from "../../MyTestDirectory"
@@ -18,6 +22,7 @@ it("should return the expected contents", async () => {
     declare global {
       interface Window {
         startNeovim(startArguments?: MyStartNeovimServerArguments): Promise<NeovimContext>
+        runBlockingShellCommand(input: BlockingCommandClientInput): Promise<BlockingShellCommandOutput>
       }
     }
@@ -36,6 +41,12 @@ it("should return the expected contents", async () => {
       })
     })
+    Cypress.Commands.add("runBlockingShellCommand", (input: BlockingCommandClientInput) => {
+      cy.window().then(async win => {
+        return await win.runBlockingShellCommand(input)
+      })
+    })
     Cypress.Commands.add("typeIntoTerminal", (text: string, options?: Partial<Cypress.TypeOptions>) => {
       // the syntax for keys is described here:
       // https://docs.cypress.io/api/commands/type
@@ -53,7 +64,14 @@ it("should return the expected contents", async () => {
       namespace Cypress {
         interface Chainable {
           startNeovim(args?: MyStartNeovimServerArguments): Chainable<NeovimContext>
+          /** Types text into the terminal, making the terminal application receive
+           * the keystrokes as input. Requires neovim to be running. */
           typeIntoTerminal(text: string, options?: Partial<Cypress.TypeOptions>): Chainable<void>
+          /** Runs a shell command in a blocking manner, waiting for the command to
+           * finish before returning. Requires neovim to be running. */
+          runBlockingShellCommand(input: BlockingCommandClientInput): Chainable<BlockingShellCommandOutput>
         }
       }
     }

package/dist/src/server/cypress-support/createCypressSupportFile.js CHANGED Viewed

@@ -14,12 +14,13 @@ export async function createCypressSupportFile({ cypressSupportDirectoryPath, su
         oldSchema = readFileSync(outputFilePath, "utf-8");
     }
     catch (error) {
-        console.log(`No existing cypress support file found at ${outputFilePath}, creating a new one`);
+        console.log(`No existing cypress support file found at ${outputFilePath}`);
     }
     if (oldSchema !== text) {
         // it's important to not write the file if the schema hasn't changed
         // because file watchers will trigger on file changes and we don't want to
         // trigger a build if the schema hasn't changed
+        console.log(`🪛 Writing cypress support file to ${outputFilePath}`);
         writeFileSync(outputFilePath, text);
         return "updated";
     }

package/dist/src/server/neovim/NeovimApplication.d.ts CHANGED Viewed

@@ -1,6 +1,8 @@
 import EventEmitter from "events";
+import type { NeovimClient as NeovimApiClient } from "neovim";
 import type { TestDirectory } from "../types.js";
 import { DisposableSingleApplication } from "../utilities/DisposableSingleApplication.js";
+import type { Lazy } from "../utilities/Lazy.js";
 export type StdoutMessage = "stdout";
 export type StartNeovimGenericArguments = {
     filename: string | {
@@ -15,15 +17,22 @@ export type TerminalDimensions = {
     cols: number;
     rows: number;
 };
+type ResettableState = {
+    testDirectory: TestDirectory;
+    socketPath: string;
+    client: Lazy<Promise<NeovimApiClient>>;
+};
 export declare class NeovimApplication {
     private readonly testEnvironmentPath;
     readonly application: DisposableSingleApplication;
-    private state;
+    state: ResettableState | undefined;
     readonly events: EventEmitter;
     constructor(testEnvironmentPath: string, application?: DisposableSingleApplication);
     /**
      * Kill the current application and start a new one with the given arguments.
      */
     startNextAndKillCurrent(testDirectory: TestDirectory, startArgs: StartNeovimGenericArguments, terminalDimensions: TerminalDimensions): Promise<void>;
+    getEnvironmentVariables(testDirectory: TestDirectory, additionalEnvironmentVariables?: Record<string, string>): NodeJS.ProcessEnv;
     [Symbol.asyncDispose](): Promise<void>;
 }
+export {};

package/dist/src/server/neovim/NeovimApplication.js CHANGED Viewed

@@ -53,18 +53,7 @@ export class NeovimApplication {
         neovimArguments.push("--listen", socketPath);
         const stdout = this.events;
         await this.application.startNextAndKillCurrent(async () => {
-            const env = {
-                ...process.env,
-                HOME: testDirectory.rootPathAbsolute,
-                // this is needed so that neovim can load its configuration, emulating
-                // a common setup real neovim users have
-                XDG_CONFIG_HOME: join(testDirectory.rootPathAbsolute, ".config"),
-                // the data directory is where lazy.nvim stores its plugins. To prevent
-                // downloading a new set of plugins for each test, share the data
-                // directory.
-                XDG_DATA_HOME: join(testDirectory.testEnvironmentPath, ".repro", "data"),
-                ...startArgs.additionalEnvironmentVariables,
-            };
+            const env = this.getEnvironmentVariables(testDirectory, startArgs.additionalEnvironmentVariables);
             return TerminalApplication.start({
                 command: "nvim",
                 args: neovimArguments,
@@ -86,6 +75,20 @@ export class NeovimApplication {
         };
         console.log(`🚀 Started Neovim instance ${processId}`);
     }
+    getEnvironmentVariables(testDirectory, additionalEnvironmentVariables) {
+        return {
+            ...process.env,
+            HOME: testDirectory.rootPathAbsolute,
+            // this is needed so that neovim can load its configuration, emulating
+            // a common setup real neovim users have
+            XDG_CONFIG_HOME: join(testDirectory.rootPathAbsolute, ".config"),
+            // the data directory is where lazy.nvim stores its plugins. To prevent
+            // downloading a new set of plugins for each test, share the data
+            // directory.
+            XDG_DATA_HOME: join(testDirectory.testEnvironmentPath, ".repro", "data"),
+            ...additionalEnvironmentVariables,
+        };
+    }
     async [Symbol.asyncDispose]() {
         await this.application[Symbol.asyncDispose]();
         if (!this.state)

package/dist/src/server/neovim/environment/createTempDir.test.js CHANGED Viewed

@@ -72,7 +72,7 @@ it("should create a temp dir with no contents", async () => {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         // typically the user will want to have contents, but this should not be an error
-        const dir = __addDisposableResource(env_1, TempDirectory.create(), true);
+        const dir = __addDisposableResource(env_1, TempDirectory.create(), false);
         const result = await createTempDir({
             testEnvironmentPath: dir.path,
             outputFilePath: nodePath.join(dir.path, "MyTestDirectory.ts"),
@@ -87,8 +87,6 @@ it("should create a temp dir with no contents", async () => {
         env_1.hasError = true;
     }
     finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
+        __disposeResources(env_1);
     }
 });

package/dist/src/server/neovim/index.d.ts CHANGED Viewed

@@ -1,4 +1,6 @@
-import type { StartNeovimGenericArguments, TestDirectory } from "../types.js";
+import "core-js/proposals/async-explicit-resource-management.js";
+import type { BlockingCommandInput } from "../server.js";
+import type { BlockingShellCommandOutput, StartNeovimGenericArguments, TestDirectory } from "../types.js";
 import type { TestServerConfig } from "../updateTestdirectorySchemaFile.js";
 import type { TabId } from "../utilities/tabId.js";
 import type { TerminalDimensions } from "./NeovimApplication.js";
@@ -10,3 +12,4 @@ export declare function sendStdin(options: {
     tabId: TabId;
     data: string;
 }): Promise<void>;
+export declare function runBlockingShellCommand(signal: AbortSignal | undefined, input: BlockingCommandInput): Promise<BlockingShellCommandOutput>;

package/dist/src/server/neovim/index.js CHANGED Viewed

@@ -1,4 +1,7 @@
 import assert from "assert";
+import { exec } from "child_process";
+import "core-js/proposals/async-explicit-resource-management.js";
+import util from "util";
 import { convertEventEmitterToAsyncGenerator } from "../utilities/generator.js";
 import { createTempDir, removeTestDirectories } from "./environment/createTempDir.js";
 import { NeovimApplication } from "./NeovimApplication.js";
@@ -33,3 +36,34 @@ export async function sendStdin(options) {
     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, input) {
+    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 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,
+        };
+    }
+    catch (e) {
+        console.warn(`Error running shell blockingCommand (${input.command})`, e);
+        return {
+            type: "failed",
+        };
+    }
+}

package/dist/src/server/server.d.ts CHANGED Viewed

@@ -1,11 +1,46 @@
 import type { inferRouterInputs } from "@trpc/server";
 import "core-js/proposals/async-explicit-resource-management.js";
+import type { Except } from "type-fest";
+import { z } from "zod";
 import { TestServer } from "./TestServer.js";
 import type { TestServerConfig } from "./updateTestdirectorySchemaFile.js";
-/** Stack for managing resources that need to be disposed of when the server
- * shuts down */
-declare const autocleanup: AsyncDisposableStack;
-export { autocleanup };
+declare const blockingCommandInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    shell: z.ZodOptional<z.ZodString>;
+    tabId: z.ZodObject<{
+        tabId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tabId: string;
+    }, {
+        tabId: string;
+    }>;
+    uid: z.ZodOptional<z.ZodNumber>;
+    gid: z.ZodOptional<z.ZodNumber>;
+    cwd: z.ZodOptional<z.ZodString>;
+    envOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    tabId: {
+        tabId: string;
+    };
+    cwd?: string | undefined;
+    uid?: number | undefined;
+    gid?: number | undefined;
+    shell?: string | undefined;
+    envOverrides?: Record<string, string> | undefined;
+}, {
+    command: string;
+    tabId: {
+        tabId: string;
+    };
+    cwd?: string | undefined;
+    uid?: number | undefined;
+    gid?: number | undefined;
+    shell?: string | undefined;
+    envOverrides?: Record<string, string> | undefined;
+}>;
+export type BlockingCommandClientInput = Except<BlockingCommandInput, "tabId">;
+export type BlockingCommandInput = z.infer<typeof blockingCommandInputSchema>;
 /** @private */
 export declare function createAppRouter(config: TestServerConfig): Promise<import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
     ctx: object;
@@ -55,8 +90,23 @@ export declare function createAppRouter(config: TestServerConfig): Promise<impor
             };
             output: void;
         }>;
+        runBlockingShellCommand: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                command: string;
+                tabId: {
+                    tabId: string;
+                };
+                cwd?: string | undefined;
+                uid?: number | undefined;
+                gid?: number | undefined;
+                shell?: string | undefined;
+                envOverrides?: Record<string, string> | undefined;
+            };
+            output: import("./types.js").BlockingShellCommandOutput;
+        }>;
     }>;
 }>>>;
 export type AppRouter = Awaited<ReturnType<typeof createAppRouter>>;
 export type RouterInput = inferRouterInputs<AppRouter>;
 export declare function startTestServer(config: TestServerConfig): Promise<TestServer>;
+export {};

package/dist/src/server/server.js CHANGED Viewed

@@ -1,55 +1,3 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 import "core-js/proposals/async-explicit-resource-management.js";
 import { z } from "zod";
 import { trpc } from "./connection/trpc.js";
@@ -57,7 +5,16 @@ import * as neovim from "./neovim/index.js";
 import { TestServer } from "./TestServer.js";
 import { applicationAvailable } from "./utilities/applicationAvailable.js";
 import { tabIdSchema } from "./utilities/tabId.js";
-export { autocleanup };
+const blockingCommandInputSchema = z.object({
+    command: z.string(),
+    shell: z.string().optional(),
+    tabId: tabIdSchema,
+    // child_process.ProcessEnvOptions
+    uid: z.number().optional(),
+    gid: z.number().optional(),
+    cwd: z.string().optional(),
+    envOverrides: z.record(z.string()).optional(),
+});
 /** @private */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export async function createAppRouter(config) {
@@ -93,6 +50,9 @@ export async function createAppRouter(config) {
             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);
+            }),
         }),
     });
     return appRouter;
@@ -105,22 +65,3 @@ export async function startTestServer(config) {
     await testServer.startAndRun(appRouter);
     return testServer;
 }
-var autocleanup;
-const env_1 = { stack: [], error: void 0, hasError: false };
-try {
-    /** Stack for managing resources that need to be disposed of when the server
-     * shuts down */
-    autocleanup = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
-    autocleanup.defer(() => {
-        console.log("Closing any open test applications");
-    });
-}
-catch (e_1) {
-    env_1.error = e_1;
-    env_1.hasError = true;
-}
-finally {
-    const result_1 = __disposeResources(env_1);
-    if (result_1)
-        await result_1;
-}

package/dist/src/server/types.d.ts CHANGED Viewed

@@ -26,3 +26,10 @@ export type TestDirectory = {
     contents: object;
 };
 export type { StartNeovimGenericArguments } from "../server/neovim/NeovimApplication.js";
+export type BlockingShellCommandOutput = {
+    type: "success";
+    stdout: string;
+    stderr: string;
+} | {
+    type: "failed";
+};