Lint

Author: PythonCoderAS

README.md

@@ -1,2 +1,3 @@
 # github-run-script
+
 Run a script on multiple repositories, cloning them if needed.

package-lock.json

@@ -15,6 +15,8 @@ const cli = sade("github-run-script <script>", true)
     "-s, --search-path",
     "A path to search for already-cloned repositories."
   )
+  .option("-t, --terminate", "Terminate any spawned processes on error.")
+  .option("-s, --signal", "The signal to terminate a process with.")
   .action(handler);
 
 export default cli;

src/cli.ts

@@ -1,14 +1,32 @@
 import { mkdtemp, readdir, stat, rm } from "fs/promises";
-import { spawn } from "child_process";
-import { CliFlags, RepoOwner } from "./types";
-import { getRepoAndOwner, waitOnChildProcessToExit } from "./utils";
+import { ChildProcess, spawn as actualSpawn } from "child_process";
 import ArrayStringMap from "array-string-map";
 import filterAsync from "node-filter-async";
 import { tmpdir } from "os";
+import { getRepoAndOwner, waitOnChildProcessToExit } from "./utils";
+import { CliFlags, RepoOwner } from "./types";
+
+// We need to make a spawn cache. If an exception is thrown,
+// we need to be able to comply with the --terminate flag..
+const spawnedProcesses: Map<ChildProcess, null> = new Map();
+
+async function spawn(command: string, args?: string[], options?: object) {
+  const childProcess = await actualSpawn(command, args, options);
+  spawnedProcesses.set(childProcess, null);
+  childProcess.on("exit", () => spawnedProcesses.delete(childProcess));
+  return childProcess;
+}
+
+// eslint-disable-next-line no-undef -- NodeJS is a fake namespace by TypeScript.
+function terminateSpawnCache(signal: NodeJS.Signals = "SIGTERM") {
+  for (const childProcess of spawnedProcesses.keys()) {
+    childProcess.kill(signal);
+  }
+}
 
 export default async function handler(script: string, flags: CliFlags) {
-  console.log(script, flags);
   const { owner: defaultOwner, _: repoNames } = flags;
+  let { search } = flags;
   const repos: RepoOwner[] = [];
   for (const repoName of repoNames) {
     try {
@@ -20,35 +38,39 @@ export default async function handler(script: string, flags: CliFlags) {
       process.exit(1);
     }
   }
+
   const tempDir = await mkdtemp(`${tmpdir()}/github-run-script-`);
   try {
     const directoryMapping: ArrayStringMap<RepoOwner, string> =
       new ArrayStringMap();
     const scanDirectories: Map<string, string[]> = new Map();
-    if (flags.search) {
+    if (search) {
       // If it's one path, it won't be in an array. This converts it into an array.
-      if (typeof flags.search === "string") {
-        flags.search = [flags.search];
+      if (typeof search === "string") {
+        search = [search];
       }
+
       // What this code block does is simple. It stores in `scanDirectories`
       // a mapping of source path name to an array of directories in that directory.
       await Promise.all(
-        flags.search.map(async (path) => {
+        search.map(async (path) => {
           scanDirectories.set(
             path,
-            await filterAsync(await readdir(path), async (item) => {
-              return (await stat(`${path}/${item}`)).isDirectory();
-            })
+            await filterAsync(await readdir(path), async (item) =>
+              (await stat(`${path}/${item}`)).isDirectory()
+            )
           );
         })
       );
     }
+
     await Promise.all(
       repos.map(async ([owner, repo]) => {
         // First, we need to check if the repository exists in `scanDirectories`.
-        // TODO: Handle cases where the same repo is present multiple times in
-        // TODO: different directories, or if two repos with the same name but
-        // TODO: different owners is provided. (Maybe we can check `.git`.)
+        // TODO:
+        // Handle cases where the same repo is present multiple times in
+        // different directories, or if two repos with the same name but
+        // different owners is provided. (Maybe we can check `.git`.)
         for (const [path, directories] of scanDirectories) {
           for (const directory of directories) {
             if (repo === directory) {
@@ -57,12 +79,14 @@ export default async function handler(script: string, flags: CliFlags) {
               break;
             }
           }
+
           // If we already found a match earlier, no need to re-iterate over the other
           // directories.
           if (directoryMapping.has([owner, repo])) {
             break;
           }
         }
+
         // Deal wit the special case where we did not find a match. Time to clone.
         if (!directoryMapping.has([owner, repo])) {
           const destPath = `${tempDir}/${repo}`;
@@ -75,6 +99,7 @@ export default async function handler(script: string, flags: CliFlags) {
           await waitOnChildProcessToExit(childProc);
           directoryMapping.set([owner, repo], destPath);
         }
+
         // Time to execute the script!
         const path = directoryMapping.get([owner, repo]);
         const childProc = await spawn(script, [], {
@@ -92,6 +117,11 @@ export default async function handler(script: string, flags: CliFlags) {
       })
     );
   } finally {
+    if (flags.terminate ?? true) {
+      // eslint-disable-next-line no-undef -- NodeJS is a fake namespace by TypeScript.
+      terminateSpawnCache(flags.signal as NodeJS.Signals);
+    }
+
     // We need to clean up the temporary directory.
     await rm(tempDir, { recursive: true, force: true });
   }

src/handler.ts

@@ -1,6 +1,8 @@
 export interface CliFlags {
   owner?: string;
   search?: string | string[];
+  terminate?: string | boolean;
+  signal?: string;
   _: string[];
 }
 

src/types.ts

@@ -1,5 +1,5 @@
-import { RepoOwner } from "./types";
 import { ChildProcess } from "child_process";
+import { RepoOwner } from "./types";
 
 export function getRepoAndOwner(
   input: string,

src/utils.ts

@@ -4,7 +4,7 @@
     "module": "commonjs",
     "outDir": "dist",
     "strict": true,
-    "target": "es2019",
+    "target": "es2019"
   },
   "include": ["src/**/*"]
 }