@take-out/scripts 0.1.37 → 0.1.38-1772433507984

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.1.37",
+  "version": "0.1.38-1772433507984",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
@@ -20,6 +20,7 @@
     }
   },
   "scripts": {
+    "postinstall": "cd src/run-group && (clang -O2 -o run-group run-group.c 2>/dev/null || gcc -O2 -o run-group run-group.c 2>/dev/null || true)",
     "lint": "oxlint src",
     "lint:fix": "oxfmt src && oxlint --fix --fix-suggestions src",
     "typecheck": "tko run typecheck"
@@ -30,7 +31,7 @@
   "dependencies": {
     "@clack/prompts": "^0.8.2",
     "@lydell/node-pty": "^1.2.0-beta.3",
-    "@take-out/helpers": "0.1.37",
+    "@take-out/helpers": "0.1.38-1772433507984",
     "picocolors": "^1.1.1"
   },
   "peerDependencies": {

package/src/helpers/run.ts

@@ -1,8 +1,39 @@
 import { spawn, type ChildProcess } from 'node:child_process'
+import { existsSync } from 'node:fs'
 import { cpus } from 'node:os'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 import type { Timer } from '@take-out/helpers'
 
+// find run-group binary for proper process group management
+let _runGroupBin: string | null | undefined
+function findRunGroupBinary(): string | null {
+  if (_runGroupBin !== undefined) return _runGroupBin
+
+  // check relative to this file (in packages/scripts/bin/)
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url))
+    const localBin = resolve(__dirname, '..', 'bin', 'run-group')
+    if (existsSync(localBin)) {
+      _runGroupBin = localBin
+      return _runGroupBin
+    }
+  } catch {}
+
+  // check in node_modules
+  try {
+    const nmBin = resolve(process.cwd(), 'node_modules', '@take-out', 'scripts', 'bin', 'run-group')
+    if (existsSync(nmBin)) {
+      _runGroupBin = nmBin
+      return _runGroupBin
+    }
+  } catch {}
+
+  _runGroupBin = null
+  return null
+}
+
 export type ProcessType = ChildProcess
 export type ProcessHandler = (process: ProcessType) => void
 
@@ -19,6 +50,39 @@ export function getIsExiting() {
 
 const processHandlers = new Set<ProcessHandler>()
 
+// track all spawned child processes for cleanup on exit
+const activeProcesses = new Set<ChildProcess>()
+
+// install cleanup handlers once
+let cleanupInstalled = false
+function installCleanupHandlers() {
+  if (cleanupInstalled) return
+  cleanupInstalled = true
+
+  const cleanup = () => {
+    for (const proc of activeProcesses) {
+      try {
+        // kill the process group to ensure child processes are also killed
+        if (proc.pid) {
+          process.kill(-proc.pid, 'SIGTERM')
+        }
+      } catch {
+        // process may already be dead
+      }
+    }
+  }
+
+  process.on('exit', cleanup)
+  process.on('SIGINT', () => {
+    cleanup()
+    process.exit(130)
+  })
+  process.on('SIGTERM', () => {
+    cleanup()
+    process.exit(143)
+  })
+}
+
 const colors = [
   '\x1b[36m', // cyan
   '\x1b[35m', // magenta
@@ -93,13 +157,22 @@ export async function run(
     let timeoutId: Timer | undefined
     let didTimeOut = false
 
+    // find run-group binary (handles process group cleanup properly)
+    const runGroupBin = findRunGroupBinary()
+
     try {
-      const shell = spawn('bash', ['-c', command], {
-        env: { ...process.env, ...env },
-        cwd,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        detached: detached ?? false,
-      })
+      // use run-group to wrap the command - it handles process groups and cleanup
+      const shell = runGroupBin
+        ? spawn(runGroupBin, ['bash', '-c', command], {
+            env: { ...process.env, ...env },
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+          })
+        : spawn('bash', ['-c', command], {
+            env: { ...process.env, ...env },
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+          })
 
       if (detached) {
         shell.unref()

package/src/run-group/build.zig

@@ -0,0 +1,24 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "run-group",
+        .root_source_file = b.path("main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    b.installArtifact(exe);
+
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+}

package/src/run-group/main.zig

@@ -0,0 +1,327 @@
+const std = @import("std");
+const posix = std.posix;
+const Allocator = std.mem.Allocator;
+
+// run-group: run commands with proper process group management
+//
+// usage:
+//   run-group <command> [args...]           # single command
+//   run-group -p <cmd1> --- <cmd2> --- ...  # parallel commands
+//
+// flags:
+//   -p, --parallel    run commands in parallel (separated by ---)
+//   -k, --keep-going  don't kill others on failure
+//   -q, --quiet       suppress output
+//   -t, --timing      show timing info
+//   --prefix <name>   prefix output with [name]
+
+const colors = [_][]const u8{
+    "\x1b[36m", // cyan
+    "\x1b[35m", // magenta
+    "\x1b[32m", // green
+    "\x1b[33m", // yellow
+    "\x1b[34m", // blue
+    "\x1b[31m", // red
+};
+const reset = "\x1b[0m";
+const bold = "\x1b[1m";
+const dim = "\x1b[2m";
+
+const Child = struct {
+    pid: posix.pid_t,
+    name: []const u8,
+    color_idx: usize,
+    start_time: i64,
+};
+
+var children: std.ArrayList(Child) = undefined;
+var keep_going = false;
+var quiet = false;
+var show_timing = false;
+var any_failed = false;
+var shutting_down = false;
+
+fn killAllChildren() void {
+    for (children.items) |child| {
+        // kill process group
+        posix.kill(-child.pid, posix.SIG.TERM) catch {};
+    }
+    // brief wait then force kill
+    std.time.sleep(50 * std.time.ns_per_ms);
+    for (children.items) |child| {
+        posix.kill(-child.pid, posix.SIG.KILL) catch {};
+    }
+}
+
+fn signalHandler(sig: c_int) callconv(.C) void {
+    shutting_down = true;
+    killAllChildren();
+    // re-raise to get proper exit
+    const default_action = posix.Sigaction{
+        .handler = .{ .handler = posix.SIG.DFL },
+        .mask = posix.empty_sigset,
+        .flags = 0,
+    };
+    posix.sigaction(@intCast(sig), &default_action, null) catch {};
+    _ = posix.raise(@intCast(sig)) catch {};
+}
+
+fn getColor(idx: usize) []const u8 {
+    return colors[idx % colors.len];
+}
+
+fn formatDuration(ms: i64) [32]u8 {
+    var buf: [32]u8 = undefined;
+    const secs = @divFloor(ms, 1000);
+    const mins = @divFloor(secs, 60);
+    const rem_secs = @rem(secs, 60);
+
+    if (mins > 0) {
+        _ = std.fmt.bufPrint(&buf, "{}m {}s", .{ mins, rem_secs }) catch "?";
+    } else if (secs > 0) {
+        _ = std.fmt.bufPrint(&buf, "{}s", .{secs}) catch "?";
+    } else {
+        _ = std.fmt.bufPrint(&buf, "{}ms", .{ms}) catch "?";
+    }
+    return buf;
+}
+
+fn runSingle(allocator: Allocator, argv: []const []const u8, prefix: ?[]const u8, color_idx: usize) !u8 {
+    const start = std.time.milliTimestamp();
+
+    const pid = try posix.fork();
+
+    if (pid == 0) {
+        // child: create new process group
+        _ = posix.setpgid(0, 0) catch {};
+
+        // exec
+        const argv_z = try allocator.allocSentinel(?[*:0]const u8, argv.len, null);
+        for (argv, 0..) |arg, i| {
+            argv_z[i] = try allocator.dupeZ(u8, arg);
+        }
+
+        const env = @as([*:null]const ?[*:0]const u8, @ptrCast(std.c.environ));
+        const err = posix.execvpeZ(argv_z[0].?, argv_z, env);
+        _ = err;
+        std.posix.exit(127);
+    }
+
+    // parent: set pgid from parent side too
+    _ = posix.setpgid(pid, pid) catch {};
+
+    // wait for child
+    const result = posix.waitpid(pid, 0);
+
+    // cleanup any stragglers in the group
+    posix.kill(-pid, posix.SIG.TERM) catch {};
+
+    const duration = std.time.milliTimestamp() - start;
+    const status = result.status;
+
+    const exit_code: u8 = if (posix.W.IFEXITED(status))
+        posix.W.EXITSTATUS(status)
+    else if (posix.W.IFSIGNALED(status))
+        128 + @as(u8, @intCast(posix.W.TERMSIG(status)))
+    else
+        1;
+
+    if (show_timing and prefix != null) {
+        _ = color_idx;
+        const dur_buf = formatDuration(duration);
+        const dur_str = std.mem.sliceTo(&dur_buf, 0);
+        const stdout = std.io.getStdOut().writer();
+        if (exit_code == 0) {
+            stdout.print("{s}✓{s} {s}{s}{s} completed in {s}{s}{s}\n", .{
+                "\x1b[32m", reset, bold, prefix.?, reset, "\x1b[33m", dur_str, reset,
+            }) catch {};
+        } else {
+            stdout.print("{s}✗{s} {s}{s}{s} failed after {s}{s}{s}\n", .{
+                "\x1b[31m", reset, bold, prefix.?, reset, "\x1b[33m", dur_str, reset,
+            }) catch {};
+        }
+    }
+
+    return exit_code;
+}
+
+fn spawnChild(allocator: Allocator, argv: []const []const u8, name: []const u8, color_idx: usize) !void {
+    const start = std.time.milliTimestamp();
+    const pid = try posix.fork();
+
+    if (pid == 0) {
+        // child
+        _ = posix.setpgid(0, 0) catch {};
+
+        const argv_z = try allocator.allocSentinel(?[*:0]const u8, argv.len, null);
+        for (argv, 0..) |arg, i| {
+            argv_z[i] = try allocator.dupeZ(u8, arg);
+        }
+
+        const env = @as([*:null]const ?[*:0]const u8, @ptrCast(std.c.environ));
+        const err = posix.execvpeZ(argv_z[0].?, argv_z, env);
+        _ = err;
+        std.posix.exit(127);
+    }
+
+    // parent
+    _ = posix.setpgid(pid, pid) catch {};
+
+    try children.append(.{
+        .pid = pid,
+        .name = name,
+        .color_idx = color_idx,
+        .start_time = start,
+    });
+}
+
+fn waitForChildren() u8 {
+    var max_exit: u8 = 0;
+
+    while (children.items.len > 0) {
+        const result = posix.waitpid(-1, 0);
+        const pid = result.pid;
+
+        // find and remove child
+        for (children.items, 0..) |child, i| {
+            if (child.pid == pid) {
+                const duration = std.time.milliTimestamp() - child.start_time;
+                const status = result.status;
+
+                const exit_code: u8 = if (posix.W.IFEXITED(status))
+                    posix.W.EXITSTATUS(status)
+                else if (posix.W.IFSIGNALED(status))
+                    128 + @as(u8, @intCast(posix.W.TERMSIG(status)))
+                else
+                    1;
+
+                if (exit_code > max_exit) max_exit = exit_code;
+
+                if (show_timing) {
+                    const stdout = std.io.getStdOut().writer();
+                    const dur_buf = formatDuration(duration);
+                    const dur_str = std.mem.sliceTo(&dur_buf, 0);
+                    if (exit_code == 0) {
+                        stdout.print("{s}✓{s} {s}{s}{s} completed in {s}{s}{s}\n", .{
+                            "\x1b[32m", reset, bold, child.name, reset, "\x1b[33m", dur_str, reset,
+                        }) catch {};
+                    } else {
+                        stdout.print("{s}✗{s} {s}{s}{s} failed after {s}{s}{s}\n", .{
+                            "\x1b[31m", reset, bold, child.name, reset, "\x1b[33m", dur_str, reset,
+                        }) catch {};
+                        any_failed = true;
+                        if (!keep_going and !shutting_down) {
+                            shutting_down = true;
+                            killAllChildren();
+                        }
+                    }
+                }
+
+                // cleanup process group
+                posix.kill(-pid, posix.SIG.TERM) catch {};
+
+                _ = children.swapRemove(i);
+                break;
+            }
+        }
+    }
+
+    return max_exit;
+}
+
+pub fn main() !u8 {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+
+    children = .{};
+    defer children.deinit(allocator);
+
+    const args = try std.process.argsAlloc(allocator);
+    defer std.process.argsFree(allocator, args);
+
+    if (args.len < 2) {
+        const stderr = std.io.getStdErr().writer();
+        try stderr.print(
+            \\usage: run-group [flags] <command> [args...]
+            \\       run-group -p <cmd1> --- <cmd2> --- ...
+            \\
+            \\flags:
+            \\  -p, --parallel    run commands in parallel (separated by ---)
+            \\  -k, --keep-going  don't kill others on failure
+            \\  -q, --quiet       suppress output
+            \\  -t, --timing      show timing info
+            \\
+        , .{});
+        return 1;
+    }
+
+    // set up signal handlers
+    const handler = posix.Sigaction{
+        .handler = .{ .handler = signalHandler },
+        .mask = posix.empty_sigset,
+        .flags = 0,
+    };
+    try posix.sigaction(posix.SIG.INT, &handler, null);
+    try posix.sigaction(posix.SIG.TERM, &handler, null);
+    try posix.sigaction(posix.SIG.HUP, &handler, null);
+
+    // parse flags
+    var parallel = false;
+    var cmd_start: usize = 1;
+
+    for (args[1..], 1..) |arg, i| {
+        if (std.mem.eql(u8, arg, "-p") or std.mem.eql(u8, arg, "--parallel")) {
+            parallel = true;
+            cmd_start = i + 1;
+        } else if (std.mem.eql(u8, arg, "-k") or std.mem.eql(u8, arg, "--keep-going")) {
+            keep_going = true;
+            cmd_start = i + 1;
+        } else if (std.mem.eql(u8, arg, "-q") or std.mem.eql(u8, arg, "--quiet")) {
+            quiet = true;
+            cmd_start = i + 1;
+        } else if (std.mem.eql(u8, arg, "-t") or std.mem.eql(u8, arg, "--timing")) {
+            show_timing = true;
+            cmd_start = i + 1;
+        } else if (arg[0] != '-') {
+            break;
+        }
+    }
+
+    if (cmd_start >= args.len) {
+        const stderr = std.io.getStdErr().writer();
+        try stderr.print("error: no command specified\n", .{});
+        return 1;
+    }
+
+    if (parallel) {
+        // split on --- and run in parallel
+        var cmds = std.ArrayList([]const []const u8).init(allocator);
+        var current_cmd = std.ArrayList([]const u8).init(allocator);
+
+        for (args[cmd_start..]) |arg| {
+            if (std.mem.eql(u8, arg, "---")) {
+                if (current_cmd.items.len > 0) {
+                    try cmds.append(try current_cmd.toOwnedSlice());
+                    current_cmd = std.ArrayList([]const u8).init(allocator);
+                }
+            } else {
+                try current_cmd.append(arg);
+            }
+        }
+        if (current_cmd.items.len > 0) {
+            try cmds.append(try current_cmd.toOwnedSlice());
+        }
+
+        // spawn all
+        for (cmds.items, 0..) |cmd, i| {
+            const name = cmd[0];
+            try spawnChild(allocator, cmd, name, i);
+        }
+
+        return waitForChildren();
+    } else {
+        // single command
+        const cmd = args[cmd_start..];
+        return try runSingle(allocator, cmd, cmd[0], 0);
+    }
+}