Add support for stdin

Author: MarcelRobitaille

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## [1.18.0] 2025-05-06
+
+- Support stdin (#145)
+
 ## [1.17.0] 2025-03-12
 
 - Make input history persistent (#140)

README.md

@@ -96,6 +96,7 @@ VSCode renders it like this:
 
 * `command`: the system command to be executed (must be in PATH). If given as an array, the elements are joined by spaces.
 * `commandArgs`: if provided, `command` is interpreted as the binary to run and `commandArgs` are the arguments. This is useful if the binary you want to run has spaces (like `C:\Program Files\*`). This translates to `child_process.execFileSync(command, commandArgs)`.
+* `stdin`: if provided, this string is sent to the standard input of the command
 * `cwd`: the directory from within it will be executed
 * `env`: key-value pairs to use as environment variables (it won't append the variables to the current existing ones. It will replace instead)
 * `useFirstResult`: skip 'Quick Pick' dialog and use first result returned from the command

package-lock.json

@@ -3,7 +3,7 @@
   "displayName": "Tasks Shell Input",
   "description": "Use shell commands as input for your tasks",
   "icon": "icon.png",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "publisher": "augustocdias",
   "repository": {
     "url": "https://github.com/augustocdias/vscode-shell-command"

package.json

@@ -248,6 +248,77 @@ test("commandArgs", async () => {
     );
 });
 
+describe("stdin", () => {
+    test("command", async () => {
+        const testDataPath = path.join(__dirname, "../test/testData/stdinCommand");
+
+        const tasksJson = await import(path.join(testDataPath, ".vscode/tasks.json"));
+        const mockData = (await import(path.join(testDataPath, "mockData.ts"))).default;
+
+        mockVscode.setMockData(mockData);
+        const input = tasksJson.inputs[0].args;
+        const context = mockExtensionContext as unknown as vscode.ExtensionContext;
+        const handler = new CommandHandler(
+            input,
+            new UserInputContext(context),
+            context,
+            child_process,
+        );
+
+        const result = await handler.handle();
+
+        expect(execSpy).toHaveBeenCalledTimes(1);
+        expect(execSpy).toHaveBeenCalledWith(
+            "python",
+            {
+                cwd: testDataPath,
+                encoding: "utf8",
+                env: undefined,
+                maxBuffer: undefined,
+            },
+            expect.anything(),
+        );
+        expect(execFileSpy).toHaveBeenCalledTimes(0);
+
+        expect(result).toBe("hello world");
+    });
+
+    test("commandArgs", async () => {
+        const testDataPath = path.join(__dirname, "../test/testData/stdincommandArgs");
+
+        const tasksJson = await import(path.join(testDataPath, ".vscode/tasks.json"));
+        const mockData = (await import(path.join(testDataPath, "mockData.ts"))).default;
+
+        mockVscode.setMockData(mockData);
+        const input = tasksJson.inputs[0].args;
+        const context = mockExtensionContext as unknown as vscode.ExtensionContext;
+        const handler = new CommandHandler(
+            input,
+            new UserInputContext(context),
+            context,
+            child_process,
+        );
+
+        const result = await handler.handle();
+
+        expect(execSpy).toHaveBeenCalledTimes(0);
+        expect(execFileSpy).toHaveBeenCalledTimes(1);
+        expect(execFileSpy).toHaveBeenCalledWith(
+            "python",
+            ["-v"],
+            {
+                cwd: testDataPath,
+                encoding: "utf8",
+                env: undefined,
+                maxBuffer: undefined,
+            },
+            expect.anything(),
+        );
+
+        expect(result).toBe("hello world");
+    });
+});
+
 test("stdio", async () => {
     const testDataPath = path.join(__dirname, "../test/testData/stdio");
 

src/lib/CommandHandler.test.ts

@@ -1,25 +1,13 @@
 import * as vscode from "vscode";
 import * as child_process from "child_process";
+import * as stream from "stream";
 import { ShellCommandOptions } from "./ShellCommandOptions";
 import { VariableResolver, Input } from "./VariableResolver";
 import { ShellCommandException } from "../util/exceptions";
 import { UserInputContext } from "./UserInputContext";
 import { QuickPickItem } from "./QuickPickItem";
 import { parseBoolean } from "./options";
 
-function promisify<T extends unknown[], R>(fn: (...args: [...T, (err: Error | null, stdout: string, stderr: string) => void]) => R) {
-    return (...args: [...T]) =>
-        new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
-            fn(...args, (err: Error | null, stdout: string, stderr: string) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve({ stdout, stderr });
-                }
-            });
-        });
-}
-
 export class CommandHandler {
     protected args: ShellCommandOptions;
     protected EOL = /\r\n|\r|\n/;
@@ -28,6 +16,7 @@ export class CommandHandler {
     protected input: Input;
     protected command: string;
     protected commandArgs: string[] | undefined;
+    protected stdin: string | undefined;
     protected rememberKey: string | undefined;
     protected subprocess: typeof child_process;
 
@@ -59,6 +48,7 @@ export class CommandHandler {
 
         this.command = command;
         this.commandArgs = this.args.commandArgs as string[] | undefined;
+        this.stdin = this.args.stdin;
 
         this.input = this.resolveTaskToInput(this.args.taskId);
 
@@ -171,7 +161,7 @@ export class CommandHandler {
         return result;
     }
 
-    protected async runCommand() {
+    protected async runCommand(): Promise<{stdout: string, stderr: string}> {
         const options: child_process.ExecSyncOptionsWithStringEncoding = {
             encoding: "utf8",
             cwd: this.args.cwd,
@@ -180,16 +170,26 @@ export class CommandHandler {
             //    shell: vscode.env.shell
         };
 
-        if (this.commandArgs !== undefined) {
-            const execFile = promisify(this.subprocess.execFile);
-            return await execFile(this.command, this.commandArgs, options);
-        } else {
-            const exec = promisify<
-                [string, child_process.ExecOptionsWithStringEncoding],
-                child_process.ChildProcess
-            >(this.subprocess.exec);
-            return exec(this.command, options);
-        }
+        return new Promise((resolve, reject) => {
+            const callback = (error: Error | null, stdout: string, stderr: string) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve({ stdout, stderr });
+                }
+            };
+
+            const child = (this.commandArgs !== undefined)
+                ? this.subprocess.execFile(this.command, this.commandArgs, options, callback)
+                : this.subprocess.exec(this.command, options, callback);
+
+            if ((this.stdin !== undefined) && (child.stdin !== null)) {
+                const stdinStream = new stream.Readable();
+                stdinStream.push(this.stdin);
+                stdinStream.push(null);
+                stdinStream.pipe(child.stdin);
+            }
+        });
     }
 
     protected parseResult(commandOutput: { stdout: string, stderr: string }):
@@ -456,6 +456,7 @@ export class CommandHandler {
             // and command args. It can happen that we see the same input twice
             // because of workspaceFolders. We cannot detect this.
             return input.args.command === other.args.command &&
+                input.args.stdin === other.args.stdin &&
                 CommandHandler.compareCommandArgs(input.args.commandArgs,
                                                    other.args.commandArgs);
         }

src/lib/CommandHandler.ts

@@ -3,6 +3,7 @@ export interface ShellCommandOptions
     cwd?: string;
     command: unknown;
     commandArgs?: unknown;
+    stdin?: string;
     env?: { [s: string]: string };
     useFirstResult?: boolean;
     useSingleResult?: boolean;

src/lib/ShellCommandOptions.ts

@@ -11,6 +11,7 @@ export type Input = {
         taskId: string;
         command: string | string[];
         commandArgs: string[] | undefined;
+        stdin: string | undefined;
         cwd: string;
         env: Record<string, string>;
     },

src/lib/VariableResolver.ts

@@ -0,0 +1,23 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Test commandArgs",
+      "type": "shell",
+      "command": "echo ${input:inputTest}",
+      "problemMatcher": []
+    }
+  ],
+  "inputs": [
+    {
+      "id": "inputTest",
+      "type": "command",
+      "command": "shellCommand.execute",
+      "args": {
+        "command": "python",
+        "stdin": "print('hello world')",
+        "useFirstResult": true
+      }
+    }
+  ]
+}

src/test/testData/stdinCommand/.vscode/tasks.json

@@ -0,0 +1,36 @@
+export default {
+  "calls": {
+    "workspace.getConfiguration().inspect()": {
+      "[\"tasks\",null,\"inputs\"]": {
+        "key": "tasks.inputs",
+        "workspaceValue": [
+          {
+            "id": "inputTest",
+            "type": "command",
+            "command": "shellCommand.execute",
+            "args": {
+              "command": "python",
+              "stdin": "print('hello world')",
+            }
+          }
+        ]
+      }
+    }
+  },
+  "staticData": {
+    "window.activeTextEditor.document.fileName": `${__dirname}/.vscode/tasks.json`,
+    "workspace.workspaceFolders": [
+      {
+        "uri": {
+          "$mid": 1,
+          "fsPath": `${__dirname}`,
+          "external": `file://${__dirname}}`,
+          "path": `${__dirname}`,
+          "scheme": "file"
+        },
+        "name": "vscode-shell-command",
+        "index": 0
+      }
+    ]
+  }
+};