@lowdep/procfile-run 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rushabh Shah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# procfile-run
+
+![Zero dependencies](https://img.shields.io/badge/dependencies-0-brightgreen) ![Node](https://img.shields.io/badge/node-%3E%3D14-blue) ![License: MIT](https://img.shields.io/badge/license-MIT-green) ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey)
+
+
+Start all your dev services with one command. Reads a standard `Procfile` and runs every process in parallel with color-coded, labeled output. Zero dependencies.
+
+Works on **Windows, Mac, and Linux** — unlike `foreman` (Ruby), `goreman`/`overmind` (Go binaries), or shell scripts.
+
+---
+
+## Install
+
+```bash
+npm install -g procfile-run
+```
+
+Or without installing:
+
+```bash
+npx procfile-run
+```
+
+---
+
+## Quick Start
+
+Create a `Procfile`:
+
+```
+web:     node server.js
+worker:  node worker.js
+redis:   redis-server --port 6379
+```
+
+Then run:
+
+```bash
+procfile-run
+```
+
+---
+
+## Example Output
+
+```
+procfile-run  Procfile
+  Starting 3 process(es)...
+
+         │ web     started  (pid 12345)  node server.js
+         │ worker  started  (pid 12346)  node worker.js
+         │ redis   started  (pid 12347)  redis-server --port 6379
+         │ Press Ctrl+C to stop all processes
+
+web    │ Listening on port 3000
+redis  │ Ready to accept connections
+worker │ Worker started, waiting for jobs...
+worker │ Processing job #1
+web    │ GET /api/jobs 200 12ms
+```
+
+---
+
+## Usage
+
+```bash
+procfile-run                     # Run ./Procfile
+procfile-run Procfile.dev        # Use a different Procfile
+procfile-run --only web,worker   # Run specific processes
+procfile-run --restart           # Auto-restart crashed processes
+procfile-run --timestamp         # Prefix lines with time
+procfile-run --env .env.local    # Load a specific env file
+procfile-run --no-env            # Don't load any .env file
+```
+
+---
+
+## Procfile Format
+
+```
+# This is a comment
+web:    node server.js
+worker: node --env-file=.env worker.js
+db:     pg_ctl start -D /usr/local/var/postgresql@14
+```
+
+Standard [Heroku Procfile](https://devcenter.heroku.com/articles/procfile) format — fully compatible with foreman, goreman, etc.
+
+---
+
+## Environment Variables
+
+By default, `procfile-run` loads `.env` from the same directory as the Procfile and merges it into each process's environment.
+
+```bash
+procfile-run --env .env.staging   # Load a specific env file
+procfile-run --no-env             # Skip .env loading
+```
+
+---
+
+## Behavior on Exit
+
+- If any process exits (success or crash), **all other processes are stopped** — unless `--restart` is active.
+- `Ctrl+C` sends `SIGTERM` to all child processes cleanly.
+- `--restart` will restart only *crashed* processes (non-zero exit), not ones that exited cleanly.
+
+---
+
+## vs. Alternatives
+
+| Tool | Runtime needed | Windows | Zero-dep |
+|---|---|---|---|
+| `foreman` | Ruby gem | ❌ | ❌ |
+| `goreman` | Go binary | ❌ | ❌ |
+| `overmind` | Go binary | ❌ | ❌ |
+| `concurrently` | npm (has deps) | ✓ | ❌ |
+| `procfile-run` | Node.js | ✓ | ✓ |
+
+---
+
+## License
+
+MIT
+
+---
+
+## Keywords
+
+`procfile` · `foreman alternative` · `overmind alternative` · `goreman alternative` · `process manager` · `run multiple processes` · `dev servers` · `concurrently alternative` · `cross-platform` · `zero dependencies`
+
+---
+
+<div align="center">
+
+**Built to solve, shared to help — Rushabh Shah 🛠️✨**
+
+<sub>One of 40+ zero-dependency developer CLI tools — no <code>node_modules</code>, ever.</sub>
+
+</div>

package/bin/procfile-run.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs           = require('fs');
+const path         = require('path');
+const child_process = require('child_process');
+
+const VERSION = '1.0.0';
+
+// ─── ANSI palette (16 distinct colors for process labels) ─────────────────────
+const isTTY    = process.stdout.isTTY;
+const c        = (code, t) => isTTY ? `\x1b[${code}m${t}\x1b[0m` : t;
+const bold     = t => c('1', t);
+const dim      = t => c('2', t);
+const red      = t => c('31', t);
+const green    = t => c('32', t);
+const yellow   = t => c('33', t);
+
+const PROC_COLORS = [
+  '36', '35', '33', '32', '34', '31', '96', '95', '93', '92', '94', '91',
+  '36;1', '35;1', '33;1', '32;1'
+];
+
+function procColor(idx, t) {
+  return isTTY ? `\x1b[${PROC_COLORS[idx % PROC_COLORS.length]}m${t}\x1b[0m` : t;
+}
+
+// ─── Procfile parser ───────────────────────────────────────────────────────────
+function parseProcfile(content) {
+  const procs = [];
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const colon = trimmed.indexOf(':');
+    if (colon === -1) continue;
+    const name = trimmed.slice(0, colon).trim();
+    const cmd  = trimmed.slice(colon + 1).trim();
+    if (name && cmd) procs.push({ name, cmd });
+  }
+  return procs;
+}
+
+// ─── .env file loader ─────────────────────────────────────────────────────────
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  const env = {};
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let   val = trimmed.slice(eq + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    env[key] = val;
+  }
+  return env;
+}
+
+// ─── Shell-split a command string ─────────────────────────────────────────────
+// Very basic: handles quoted args and space separation
+function shellSplit(cmd) {
+  const parts = [];
+  let cur = '', inSingle = false, inDouble = false;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (ch === "'" && !inDouble) { inSingle = !inSingle; }
+    else if (ch === '"' && !inSingle) { inDouble = !inDouble; }
+    else if (ch === ' ' && !inSingle && !inDouble) {
+      if (cur) { parts.push(cur); cur = ''; }
+    } else { cur += ch; }
+  }
+  if (cur) parts.push(cur);
+  return parts;
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+const args        = process.argv.slice(2);
+const VALUE_FLAGS  = new Set(['--env', '--only']);
+const positional = [];
+for (let i = 0; i < args.length; i++) {
+  if (args[i].startsWith('-')) { if (VALUE_FLAGS.has(args[i])) i++; }
+  else positional.push(args[i]);
+}
+
+function getFlag(f) {
+  const i = args.indexOf(f);
+  return i !== -1 ? args[i + 1] : null;
+}
+function hasFlag(f) { return args.includes(f); }
+
+if (hasFlag('--version') || hasFlag('-v')) {
+  console.log(`procfile-run v${VERSION}`); process.exit(0);
+}
+
+if (hasFlag('--help') || hasFlag('-h')) {
+  console.log(`
+${bold('procfile-run')} — Run all processes defined in a Procfile
+
+${bold('USAGE')}
+  procfile-run [Procfile] [options]
+
+${bold('OPTIONS')}
+  --only <names>    Comma-separated list of process names to run
+  --env <file>      Load additional env vars from a file (default: .env)
+  --no-env          Don't load .env file
+  --restart         Restart crashed processes automatically
+  --timestamp       Prefix log lines with timestamp
+  --version         Show version
+
+${bold('EXAMPLES')}
+  procfile-run                     # Run all processes in ./Procfile
+  procfile-run Procfile.dev        # Use a different Procfile
+  procfile-run --only web,worker   # Run only web and worker
+  procfile-run --restart           # Auto-restart on crash
+
+${bold('PROCFILE FORMAT')}
+  # comment
+  web:    node server.js
+  worker: node worker.js
+  redis:  redis-server --port 6379
+`);
+  process.exit(0);
+}
+
+// Locate Procfile
+const procfilePath = positional[0]
+  ? path.resolve(positional[0])
+  : (() => {
+    for (const name of ['Procfile', 'procfile', 'PROCFILE', 'Procfile.dev']) {
+      const p = path.join(process.cwd(), name);
+      if (fs.existsSync(p)) return p;
+    }
+    return null;
+  })();
+
+if (!procfilePath || !fs.existsSync(procfilePath)) {
+  console.error(red(`\nNo Procfile found. Create a Procfile or specify one:\n  procfile-run ./Procfile\n`));
+  process.exit(1);
+}
+
+const onlyFilter    = getFlag('--only') ? new Set(getFlag('--only').split(',').map(s => s.trim())) : null;
+const envFile       = hasFlag('--no-env') ? null : (getFlag('--env') || path.join(path.dirname(procfilePath), '.env'));
+const autoRestart   = hasFlag('--restart');
+const showTimestamp = hasFlag('--timestamp');
+
+// Load env
+const extraEnv = envFile ? loadEnvFile(envFile) : {};
+const procEnv  = { ...process.env, ...extraEnv };
+
+// Parse Procfile
+const allProcs = parseProcfile(fs.readFileSync(procfilePath, 'utf8'));
+const procs    = onlyFilter ? allProcs.filter(p => onlyFilter.has(p.name)) : allProcs;
+
+if (!procs.length) {
+  console.error(yellow(`\nNo processes found in ${path.basename(procfilePath)}\n`));
+  process.exit(1);
+}
+
+// Compute label width for aligned output
+const labelWidth = Math.max(...procs.map(p => p.name.length));
+
+function log(procIdx, procName, line) {
+  const label     = procColor(procIdx, procName.padEnd(labelWidth));
+  const separator = dim('│');
+  const ts        = showTimestamp ? dim(new Date().toLocaleTimeString() + ' ') : '';
+  process.stdout.write(`${label} ${separator} ${ts}${line}\n`);
+}
+
+function logSystem(msg) {
+  console.log(dim(`${''.padEnd(labelWidth)} │ ${msg}`));
+}
+
+console.log(`\n${bold('procfile-run')}  ${dim(path.basename(procfilePath))}`);
+console.log(dim(`  Starting ${procs.length} process(es)...\n`));
+
+// ─── Process management ───────────────────────────────────────────────────────
+const children = new Map();  // name → ChildProcess
+let   shuttingDown = false;
+
+const isWin = process.platform === 'win32';
+
+// On Windows, npm/npx/yarn/pnpm ship as .cmd wrappers — resolve them explicitly
+// so we can avoid shell:true (which triggers a deprecation warning).
+const WIN_CMD_SHIMS = new Set(['npm', 'npx', 'yarn', 'pnpm', 'tsc', 'ts-node', 'vite', 'next', 'jest', 'eslint', 'prettier']);
+
+function resolveWinBin(bin) {
+  if (!isWin) return { bin, useShell: false };
+  const base = path.basename(bin, path.extname(bin)).toLowerCase();
+  if (WIN_CMD_SHIMS.has(base)) {
+    // Try to find the .cmd in node_modules/.bin or PATH
+    for (const dir of (process.env.PATH || '').split(';')) {
+      const candidate = path.join(dir, bin + '.cmd');
+      if (fs.existsSync(candidate)) return { bin: candidate, useShell: false };
+    }
+    // Fallback: cmd.exe /c handles .cmd resolution safely
+    return { bin: 'cmd.exe', useShell: false, prefix: ['/c', bin] };
+  }
+  return { bin, useShell: false };
+}
+
+function spawnProc(proc, idx) {
+  const parts = shellSplit(proc.cmd);
+  let   bin   = parts[0];
+  let   argv  = parts.slice(1);
+
+  if (isWin) {
+    const { bin: resolvedBin, prefix } = resolveWinBin(bin);
+    bin  = resolvedBin;
+    if (prefix) argv = [...prefix, ...argv];
+  }
+
+  const child = child_process.spawn(bin, argv, {
+    env: procEnv,
+    cwd: path.dirname(procfilePath),
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  children.set(proc.name, child);
+  logSystem(`${procColor(idx, proc.name)} started  (pid ${child.pid})  ${dim(proc.cmd)}`);
+
+  child.stdout.on('data', data => {
+    for (const line of data.toString().split(/\r?\n/).filter(Boolean)) {
+      log(idx, proc.name, line);
+    }
+  });
+
+  child.stderr.on('data', data => {
+    for (const line of data.toString().split(/\r?\n/).filter(Boolean)) {
+      log(idx, proc.name, red(line));
+    }
+  });
+
+  child.on('exit', (code, signal) => {
+    children.delete(proc.name);
+    if (shuttingDown) return;
+    const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+    if (code === 0) {
+      logSystem(`${procColor(idx, proc.name)} exited  (${reason})`);
+    } else {
+      logSystem(red(`${proc.name} crashed  (${reason})`));
+    }
+    if (autoRestart && !shuttingDown && code !== 0) {
+      logSystem(yellow(`${proc.name} restarting in 1s...`));
+      setTimeout(() => spawnProc(proc, idx), 1000);
+    } else if (!autoRestart && !shuttingDown) {
+      // If any process exits, kill the rest
+      logSystem(yellow(`${proc.name} exited — stopping all processes`));
+      shutdown(1);
+    }
+  });
+
+  child.on('error', err => {
+    logSystem(red(`${proc.name} error: ${err.message}`));
+    if (!autoRestart) shutdown(1);
+  });
+}
+
+function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log();
+  logSystem('Stopping all processes...');
+  for (const [name, child] of children) {
+    try {
+      if (isWin) {
+        child_process.spawnSync('taskkill', ['/PID', String(child.pid), '/T', '/F']);
+      } else {
+        process.kill(-child.pid, 'SIGTERM');
+      }
+    } catch { /* process may already be gone */ }
+  }
+  setTimeout(() => process.exit(exitCode), 500);
+}
+
+// Catch CTRL+C
+process.on('SIGINT', () => shutdown(0));
+process.on('SIGTERM', () => shutdown(0));
+
+// Start all processes
+procs.forEach((proc, idx) => spawnProc(proc, idx));
+
+console.log();
+logSystem(dim(`Press Ctrl+C to stop all processes`));
+console.log();

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lowdep/procfile-run",
+  "version": "1.0.0",
+  "description": "Procfile process runner — start all your dev services with one command, zero dependencies",
+  "bin": {
+    "procfile-run": "bin/procfile-run.js"
+  },
+  "keywords": [
+    "procfile",
+    "foreman",
+    "process-manager",
+    "cli",
+    "developer-tools",
+    "dev-server",
+    "heroku",
+    "foreman alternative",
+    "overmind alternative",
+    "goreman alternative",
+    "process manager",
+    "run multiple processes",
+    "dev servers",
+    "concurrently alternative",
+    "cross-platform",
+    "zero dependencies"
+  ],
+  "author": "Rushabh Shah",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "bin/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rushabh5000/procfile-run.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rushabh5000/procfile-run/issues"
+  },
+  "homepage": "https://github.com/Rushabh5000/procfile-run#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}