Merge pull request #59 from thefrontside/tm/import-watch

I'm commenting out the test on linux until the underlying issue with Deno can be resolved.

Author: cowboyd

.github/workflows/verify.yaml

@@ -28,4 +28,4 @@ jobs:
 
       - run: deno lint
 
-      - run: deno test --allow-net --allow-read --allow-write
+      - run: deno test --allow-net --allow-read --allow-write --allow-env --allow-run

deno.json

@@ -1,8 +1,5 @@
 {
   "imports": {
-    "effection": "npm:effection@3.0.3",
-    "revolution": "https://deno.land/x/revolution@0.6.0/mod.ts",
-    "revolution/jsx-runtime": "https://deno.land/x/revolution@0.6.0/jsx-runtime.ts",
     "bdd": "jsr:@std/testing/bdd",
     "expect": "jsr:@std/expect"
   },
@@ -31,6 +28,8 @@
     "./test-adapter",
     "./tinyexec",
     "./timebox",
+    "./tinyexec",
+    "./watch",
     "./websocket",
     "./worker"
   ]

tasks/lib/read-packages.ts

@@ -1,4 +1,4 @@
-import { call, type Operation } from "effection";
+import { call, type Operation } from "npm:effection@3.2.1";
 import { resolve } from "jsr:@std/path@^1.0.6";
 import { z } from "npm:zod@3.23.8";
 

tasks/publish-matrix.ts

@@ -1,4 +1,4 @@
-import { call, main } from "effection";
+import { call, main } from "npm:effection@3.2.1";
 import { x } from "../tinyexec/mod.ts";
 import { readPackages } from "./lib/read-packages.ts";
 

watch/.gitignore

@@ -0,0 +1,3 @@
+/test/temp/
+*.tmp-*
+watch

watch/README.md

@@ -0,0 +1,37 @@
+# @effection-contrib/watch
+
+Watch is a very simple tool that does one thing: run a command, and every time
+source files change in a directory, shutdown the current invocation _gracefully_
+and restart it.
+
+```
+deno -A jsr:@effection-contrib/watch npm start
+```
+
+## Graceful Shutdown
+
+Watch will send SIGINT and SIGTERM to your command, and then wait until its
+`stdout` stream is closed, indicating that it has no further output. It will not
+attempt to start your command again until that has happened. This is important,
+because your process might be holding onto any number of resources that have to
+be safely released before exiting.
+
+## Git aware
+
+If you are running this command inside a git repository, it will only perform
+restarts on files that are under source control, or could be candidates for
+source control (not ignored).
+
+## Use it as a library
+
+```ts
+import { main } from "effection";
+import { watch } from "@effection-contrib/watch";
+
+await main(function* () {
+  const watcher = yield* watch({
+    path: "./src",
+    cmd: "npm test",
+  });
+});
+```

watch/child-process.ts

@@ -0,0 +1,85 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import type { Signals } from "npm:@types/node@16.18.126";
+
+import type { Operation, Stream } from "effection";
+import {
+  action,
+  createSignal,
+  resource,
+  spawn,
+  withResolvers,
+} from "effection";
+
+export interface ProcessResult {
+  code: number;
+  signal?: Signals;
+}
+
+export interface Process extends Operation<ProcessResult> {
+  stdout: Stream<string, void>;
+  stderr: Stream<string, void>;
+  send(signal: Signals): void;
+}
+
+export function useProcess(command: string): Operation<Process> {
+  return resource(function* (provide) {
+    let closed = withResolvers<ProcessResult>();
+    let stdout = createSignal<string, void>();
+    let stderr = createSignal<string, void>();
+    let nodeproc = nodeSpawn(command, {
+      shell: true,
+      stdio: "pipe",
+    });
+
+    // fail on an "error" event, but only until the process is successfully spawned.
+    yield* spawn(function* () {
+      yield* spawn(() =>
+        action<void>((_, reject) => {
+          nodeproc.on("error", reject);
+          return () => nodeproc.off("error", reject);
+        })
+      );
+
+      yield* action((resolve) => {
+        nodeproc.on("spawn", resolve);
+        return () => nodeproc.off("spawn", resolve);
+      });
+    });
+
+    let onstdout = (chunk: unknown) => {
+      stdout.send(String(chunk));
+    };
+    let onstderr = (chunk: unknown) => {
+      stderr.send(String(chunk));
+    };
+    let onclose = (code: number, signal?: Signals) => {
+      stdout.close();
+      stderr.close();
+      closed.resolve({ code, signal });
+    };
+
+    try {
+      nodeproc.stdout.on("data", onstdout);
+      nodeproc.stderr.on("data", onstderr);
+      nodeproc.on("close", onclose);
+
+      yield* provide({
+        [Symbol.iterator]: closed.operation[Symbol.iterator],
+        stdout,
+        stderr,
+        *send(signal) {
+          nodeproc.kill(signal);
+        },
+      });
+    } finally {
+      nodeproc.kill("SIGINT");
+      nodeproc.kill("SIGTERM");
+      yield* closed.operation;
+      stdout.close();
+      stderr.close();
+      nodeproc.stdout.off("data", onstdout);
+      nodeproc.stderr.off("data", onstderr);
+      nodeproc.off("close", onclose);
+    }
+  });
+}

watch/deno.json

@@ -0,0 +1,26 @@
+{
+  "name": "@effection-contrib/watch",
+  "version": "0.1.0",
+  "exports": {
+    ".": "./main.ts",
+    "./lib": "./mod.ts"
+  },
+  "imports": {
+    "effection": "npm:effection@^4.0.0-alpha.6",
+    "ignore": "npm:ignore@^7.0.3",
+    "@std/fs": "jsr:@std/fs@^1.0.11",
+    "@std/path": "jsr:@std/path@^1.0.8",
+    "chokidar": "npm:chokidar@^4.0.3",
+    "zod": "npm:zod@^3.20.2",
+    "zod-opts": "npm:zod-opts@0.1.8"
+  },
+  "lint": {
+    "rules": {
+      "exclude": ["prefer-const", "require-yield"]
+    }
+  },
+  "tasks": {
+    "compile": "deno compile --allow-env --allow-read --allow-run main.ts",
+    "dev": "deno --allow-env --allow-read --allow-run main.ts deno task compile"
+  }
+}

watch/deno.lock

@@ -0,0 +1,83 @@
+import { each, exit, main, scoped, spawn } from "effection";
+import { watch } from "./watch.ts";
+import { parser } from "zod-opts";
+import { z } from "zod";
+import process from "node:process";
+import denoJson from "./deno.json" with { type: "json" };
+
+const builtins = ["-h", "--help", "-V", "--version"];
+
+await main(function* (argv) {
+  let { args, rest } = extract(argv);
+  parser()
+    .name("watch")
+    .description(
+      "run a command, and restart it every time a source file in a directory changes",
+    )
+    .args([
+      {
+        name: "command",
+        type: z.array(z.string()).optional(),
+      },
+    ])
+    .version(denoJson.version)
+    .parse(args);
+
+  if (rest.length === 0) {
+    yield* exit(5, "no command specified to watch");
+  }
+
+  let command = rest.join(" ");
+
+  let watcher = watch({
+    path: process.cwd(),
+    cmd: command,
+  });
+
+  for (let start of yield* each(watcher)) {
+    process.stdout.write(`${command}\n`);
+    yield* scoped(function* () {
+      let { result } = start;
+      if (result.ok) {
+        let proc = result.value;
+        yield* spawn(function* () {
+          for (let chunk of yield* each(proc.stdout)) {
+            process.stdout.write(chunk);
+            yield* each.next();
+          }
+        });
+        yield* spawn(function* () {
+          for (let chunk of yield* each(proc.stderr)) {
+            process.stderr.write(chunk);
+            yield* each.next();
+          }
+        });
+      } else {
+        console.error(`failed to start: ${result.error}`);
+      }
+      yield* start.restarting;
+      process.stdout.write(`--> restarting....\n`);
+      yield* each.next();
+    });
+  }
+});
+
+interface Extract {
+  args: string[];
+  rest: string[];
+}
+
+function extract(argv: string[]): Extract {
+  let args: string[] = [];
+  let rest: string[] = argv.slice();
+
+  for (let arg = rest.shift(); arg; arg = rest.shift()) {
+    if (builtins.includes(arg)) {
+      args.push(arg);
+    } else {
+      rest.unshift(arg);
+      break;
+    }
+  }
+  return { args, rest };
+}