proctide 0.1.0__tar.gz

proctide-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 proctide contributors
+
+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.

proctide-0.1.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: proctide
+Version: 0.1.0
+Summary: Run every process in your Procfile at once in one terminal, each output line prefixed with a colored process name; a clean Ctrl-C shuts them all down. Like foreman/overmind but zero-dependency and dual-runtime — no Ruby, no tmux.
+Author: yyfjj
+License: MIT
+Project-URL: Homepage, https://github.com/jjdoor/proctide-py
+Project-URL: Repository, https://github.com/jjdoor/proctide-py
+Project-URL: Issues, https://github.com/jjdoor/proctide-py/issues
+Keywords: procfile,foreman,overmind,process,process-manager,concurrent,runner,dev,devtools,cli,monorepo
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# proctide
+
+**Run every process in your `Procfile` together, in one terminal.** Each output
+line is prefixed with a colored process name so you can tell `web` from `worker`
+from `css` at a glance — and a single Ctrl-C takes the whole lot down cleanly.
+
+Zero dependencies (pure Python stdlib). No Ruby. No tmux.
+
+```bash
+pipx run proctide
+```
+
+```
+web    | listening on http://localhost:3000
+worker | polling jobs queue…
+css    | rebuilt app.css in 42ms
+web    | GET /  200  11ms
+worker | processed job #1841
+^C
+proctide: SIGINT received, shutting down…
+web    | exited (signal SIGTERM)
+worker | exited (signal SIGTERM)
+css    | exited (signal SIGTERM)
+```
+
+## Why another Procfile runner?
+
+[foreman](https://github.com/ddollar/foreman) is the classic, but it's a **Ruby
+gem** — one more runtime to install on a Node/Python box.
+[overmind](https://github.com/DarthSim/overmind) is great but needs **tmux**.
+[`concurrently`](https://www.npmjs.com/package/concurrently) is excellent and
+mature — but it's an npm dependency, and you spell your processes out on the
+command line instead of in a checked-in `Procfile`.
+
+`proctide` is the small middle ground: a real `Procfile`, prefixed interleaved
+output, clean shutdown — and **nothing to install but the tool itself**, on
+whichever of Python or Node you already have.
+
+## Install
+
+```bash
+pipx run proctide          # no install, run on demand
+pip install proctide       # or install the `proctide` command
+```
+
+There's an identical Node build too: `npx proctide` / `npm i -g proctide`
+(see [proctide](https://github.com/jjdoor/proctide)). Both ports parse the same
+Procfile and print the same prefix format — their pure cores are tested against
+the same vectors.
+
+## The Procfile
+
+One process per line, `name: command`. Blank lines and `#` comments are ignored.
+The command runs through your shell, so pipes, `&&`, env vars, and globs all work.
+
+```Procfile
+# Procfile
+web:    python server.py
+worker: python worker.py
+css:    npx tailwindcss -i app.css -o public/app.css --watch
+```
+
+```bash
+proctide                 # runs ./Procfile
+proctide -f Procfile.dev # or point somewhere else
+```
+
+## Usage
+
+```bash
+proctide [options]
+```
+
+| Option | Description |
+| --- | --- |
+| `-f, --file <path>` | Procfile to read (default: `./Procfile`). |
+| `--no-color` | Disable the colored name prefixes (e.g. when piping to a file). |
+| `-h, --help` | Show help. |
+| `-v, --version` | Print version. |
+
+### Behavior
+
+- **Concurrent.** Every process starts at once; their stdout *and* stderr are
+  merged into one stream, each line tagged `name | …`. The name column is padded
+  to the longest process name so the `|` separators line up.
+- **Clean shutdown.** Ctrl-C (SIGINT) — or SIGTERM — forwards SIGTERM to every
+  child's process group, waits briefly, then exits. A child that ignores SIGTERM
+  gets SIGKILL as a backstop.
+- **One dies, all stop.** If any process exits on its own, the rest are shut down
+  too — that's the foreman/overmind contract for a dev stack.
+- **Honest exit code.** `proctide` exits non-zero if any child exited non-zero,
+  so it behaves in CI and `Makefile`s.
+
+## Design notes
+
+- **A pure core, an IO shell.** `parse_procfile`, `color_for`, and `prefix_line`
+  are pure functions — no spawn, no clock, no signals — which is what lets the
+  Python and Node ports be proven identical against one shared vector table. The
+  spawning/streaming/signal-forwarding lives in a separate runner module and is
+  covered by an integration smoke test instead (live output is nondeterministic).
+- **Prefixes align by construction.** The name is padded to `width` *before* any
+  ANSI color is applied, so the escape codes never throw off the columns.
+- **Zero dependencies.** Python uses `subprocess.Popen` + one reader thread per
+  process behind a shared lock so prefixed lines never interleave mid-line; Node
+  uses `child_process.spawn` + `readline`.
+
+## License
+
+MIT

proctide-0.1.0/README.md

@@ -0,0 +1,109 @@
+# proctide
+
+**Run every process in your `Procfile` together, in one terminal.** Each output
+line is prefixed with a colored process name so you can tell `web` from `worker`
+from `css` at a glance — and a single Ctrl-C takes the whole lot down cleanly.
+
+Zero dependencies (pure Python stdlib). No Ruby. No tmux.
+
+```bash
+pipx run proctide
+```
+
+```
+web    | listening on http://localhost:3000
+worker | polling jobs queue…
+css    | rebuilt app.css in 42ms
+web    | GET /  200  11ms
+worker | processed job #1841
+^C
+proctide: SIGINT received, shutting down…
+web    | exited (signal SIGTERM)
+worker | exited (signal SIGTERM)
+css    | exited (signal SIGTERM)
+```
+
+## Why another Procfile runner?
+
+[foreman](https://github.com/ddollar/foreman) is the classic, but it's a **Ruby
+gem** — one more runtime to install on a Node/Python box.
+[overmind](https://github.com/DarthSim/overmind) is great but needs **tmux**.
+[`concurrently`](https://www.npmjs.com/package/concurrently) is excellent and
+mature — but it's an npm dependency, and you spell your processes out on the
+command line instead of in a checked-in `Procfile`.
+
+`proctide` is the small middle ground: a real `Procfile`, prefixed interleaved
+output, clean shutdown — and **nothing to install but the tool itself**, on
+whichever of Python or Node you already have.
+
+## Install
+
+```bash
+pipx run proctide          # no install, run on demand
+pip install proctide       # or install the `proctide` command
+```
+
+There's an identical Node build too: `npx proctide` / `npm i -g proctide`
+(see [proctide](https://github.com/jjdoor/proctide)). Both ports parse the same
+Procfile and print the same prefix format — their pure cores are tested against
+the same vectors.
+
+## The Procfile
+
+One process per line, `name: command`. Blank lines and `#` comments are ignored.
+The command runs through your shell, so pipes, `&&`, env vars, and globs all work.
+
+```Procfile
+# Procfile
+web:    python server.py
+worker: python worker.py
+css:    npx tailwindcss -i app.css -o public/app.css --watch
+```
+
+```bash
+proctide                 # runs ./Procfile
+proctide -f Procfile.dev # or point somewhere else
+```
+
+## Usage
+
+```bash
+proctide [options]
+```
+
+| Option | Description |
+| --- | --- |
+| `-f, --file <path>` | Procfile to read (default: `./Procfile`). |
+| `--no-color` | Disable the colored name prefixes (e.g. when piping to a file). |
+| `-h, --help` | Show help. |
+| `-v, --version` | Print version. |
+
+### Behavior
+
+- **Concurrent.** Every process starts at once; their stdout *and* stderr are
+  merged into one stream, each line tagged `name | …`. The name column is padded
+  to the longest process name so the `|` separators line up.
+- **Clean shutdown.** Ctrl-C (SIGINT) — or SIGTERM — forwards SIGTERM to every
+  child's process group, waits briefly, then exits. A child that ignores SIGTERM
+  gets SIGKILL as a backstop.
+- **One dies, all stop.** If any process exits on its own, the rest are shut down
+  too — that's the foreman/overmind contract for a dev stack.
+- **Honest exit code.** `proctide` exits non-zero if any child exited non-zero,
+  so it behaves in CI and `Makefile`s.
+
+## Design notes
+
+- **A pure core, an IO shell.** `parse_procfile`, `color_for`, and `prefix_line`
+  are pure functions — no spawn, no clock, no signals — which is what lets the
+  Python and Node ports be proven identical against one shared vector table. The
+  spawning/streaming/signal-forwarding lives in a separate runner module and is
+  covered by an integration smoke test instead (live output is nondeterministic).
+- **Prefixes align by construction.** The name is padded to `width` *before* any
+  ANSI color is applied, so the escape codes never throw off the columns.
+- **Zero dependencies.** Python uses `subprocess.Popen` + one reader thread per
+  process behind a shared lock so prefixed lines never interleave mid-line; Node
+  uses `child_process.spawn` + `readline`.
+
+## License
+
+MIT

proctide-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "proctide"
+version = "0.1.0"
+description = "Run every process in your Procfile at once in one terminal, each output line prefixed with a colored process name; a clean Ctrl-C shuts them all down. Like foreman/overmind but zero-dependency and dual-runtime — no Ruby, no tmux."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "yyfjj" }]
+keywords = ["procfile", "foreman", "overmind", "process", "process-manager", "concurrent", "runner", "dev", "devtools", "cli", "monorepo"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX",
+    "Operating System :: MacOS",
+    "Operating System :: Unix",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: System :: Systems Administration",
+    "Topic :: Utilities",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/jjdoor/proctide-py"
+Repository = "https://github.com/jjdoor/proctide-py"
+Issues = "https://github.com/jjdoor/proctide-py/issues"
+
+[project.scripts]
+proctide = "proctide.cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

proctide-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

proctide-0.1.0/src/proctide/__init__.py

@@ -0,0 +1,6 @@
+"""proctide — run your Procfile's processes together, one colored prefix each."""
+
+from .core import parse_procfile, color_for, prefix_line, PALETTE
+
+__version__ = "0.1.0"
+__all__ = ["parse_procfile", "color_for", "prefix_line", "PALETTE"]

proctide-0.1.0/src/proctide/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

proctide-0.1.0/src/proctide/cli.py

@@ -0,0 +1,108 @@
+"""proctide command-line interface — read a Procfile, hand it to the runner."""
+
+import os
+import sys
+
+from . import core, runner
+
+VERSION = "0.1.0"
+
+_COLOR = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
+
+
+def _c(code, s):
+    return f"\x1b[{code}m{s}\x1b[0m" if _COLOR else s
+
+
+def bold(s): return _c("1", s)
+def dim(s): return _c("2", s)
+
+
+HELP = f"""{bold('proctide')} — run your Procfile's processes together, one colored prefix each.
+
+{bold('Usage')}
+  proctide [options]            # runs ./Procfile
+  proctide -f Procfile.dev
+
+  proctide                      # web | … / worker | … / css | … interleaved
+  proctide --no-color | tee dev.log
+
+{bold('Options')}
+  -f, --file <path>     Procfile to read (default: ./Procfile)
+      --no-color        disable colored name prefixes
+  -h, --help            show this help
+  -v, --version         print version
+
+{bold('Procfile format')}
+  {dim('# one process per line: name: command')}
+  web: python server.py
+  worker: python worker.py
+  css: npx tailwindcss -i in.css -o out.css --watch
+
+{bold('What it does')}
+  - spawns every process at once; each output line is prefixed {_c('36', 'web')} | … {_c('32', 'worker')} | …
+  - Ctrl-C sends SIGTERM to all children, waits, then exits
+  - exits non-zero if any process exited non-zero
+  - zero dependencies — like foreman, but no Ruby and no tmux
+"""
+
+
+def die(msg):
+    sys.stderr.write(f"proctide: {msg}\n")
+    sys.exit(2)
+
+
+def _value(argv, i):
+    if i + 1 >= len(argv):
+        die(f"{argv[i]} needs a value")
+    return argv[i + 1]
+
+
+def parse_args(argv):
+    opts = {"file": "Procfile", "color": None}
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a in ("-f", "--file"):
+            opts["file"] = _value(argv, i); i += 2; continue
+        if a == "--color":
+            opts["color"] = True; i += 1; continue
+        if a == "--no-color":
+            opts["color"] = False; i += 1; continue
+        die(f'unknown option "{a}" (try --help)')
+    return opts
+
+
+def main(argv=None):
+    argv = sys.argv[1:] if argv is None else argv
+    if "-h" in argv or "--help" in argv:
+        sys.stdout.write(HELP)
+        return 0
+    if "-v" in argv or "--version" in argv:
+        sys.stdout.write(VERSION + "\n")
+        return 0
+
+    opts = parse_args(argv)
+
+    if opts["color"] is None:
+        opts["color"] = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
+
+    try:
+        with open(opts["file"], "r", encoding="utf-8") as f:
+            text = f.read()
+    except FileNotFoundError:
+        die(f'no Procfile at "{os.path.abspath(opts["file"])}" (use -f to point elsewhere)')
+    except OSError as e:
+        die(f'could not read "{opts["file"]}": {e}')
+
+    entries, errors = core.parse_procfile(text)
+    for err in errors:
+        sys.stderr.write(dim(f'proctide: ignoring {opts["file"]}:{err["line"]} — {err["reason"]}') + "\n")
+    if not entries:
+        die(f'no runnable processes found in "{opts["file"]}"')
+
+    return runner.run(entries, color=opts["color"])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

proctide-0.1.0/src/proctide/core.py

@@ -0,0 +1,89 @@
+"""proctide core — pure Procfile parsing & line-prefix formatting.
+
+No spawn, no fs, no clock, no signals, no streams.
+
+The whole tool is one idea: run every process in a Procfile at once in a single
+terminal, and tag each line of output with a colored, padded process name so you
+can tell ``web`` from ``worker`` from ``css`` at a glance — then a clean Ctrl-C
+takes the whole lot down. foreman does this in Ruby; overmind needs tmux.
+proctide is zero-dependency and ships for both Node and Python.
+
+Everything in this file is a pure function of its arguments, so this port and
+the Node one are checked against the exact same input -> output vectors
+(tests/test_core.py and test/core.test.js share one VECTORS table). The live
+runner — concurrent spawn, interleaved streams, signal forwarding — is
+inherently nondeterministic and lives in runner.py, behavior-aligned but not
+vector-tested.
+"""
+
+# Deterministic ANSI foreground palette, cycled by process index. Picked to be
+# readable on a dark terminal and distinct from each other. Codes are shared
+# verbatim with the Node port. (No red — red reads as "error".)
+PALETTE = ["36", "32", "33", "34", "35", "96", "92", "93"]
+
+
+def parse_procfile(text):
+    """Parse Procfile text into an ordered list of ``{"name", "cmd"}`` dicts.
+
+    Format (foreman-compatible subset): one process per line, ``name: command``.
+      - blank lines and lines whose first non-space char is ``#`` are skipped
+      - the name is everything before the FIRST colon; the command is the rest,
+        so a command may freely contain extra colons (``sh -c 'date: now'``)
+      - name and command are both trimmed
+      - a line with no colon, an empty name, or an empty command is ignored
+        (it cannot be run) and recorded in the returned ``errors`` list
+
+    Returns ``(entries, errors)`` where ``entries`` is a list of dicts and
+    ``errors`` is a list of ``{"line", "text", "reason"}`` dicts. Mirrors the
+    Node port, whose array carries the same errors as an attached property.
+    """
+    entries = []
+    errors = []
+    lines = str(text).split("\n")
+    for i, raw in enumerate(lines):
+        # Match Node's /\r?\n/ split: drop a trailing CR if present.
+        if raw.endswith("\r"):
+            raw = raw[:-1]
+        line_no = i + 1
+        stripped = raw.strip()
+        if stripped == "" or stripped[0] == "#":
+            continue
+        colon = raw.find(":")
+        if colon == -1:
+            errors.append({"line": line_no, "text": stripped, "reason": 'no colon (expected "name: command")'})
+            continue
+        name = raw[:colon].strip()
+        cmd = raw[colon + 1:].strip()
+        if name == "":
+            errors.append({"line": line_no, "text": stripped, "reason": "empty process name"})
+            continue
+        if cmd == "":
+            errors.append({"line": line_no, "text": stripped, "reason": "empty command"})
+            continue
+        entries.append({"name": name, "cmd": cmd})
+    return entries, errors
+
+
+def color_for(index):
+    """Deterministic ANSI color code for the Nth process, cycling the palette.
+
+    Negative indices wrap too (defensive; the runner only ever passes >= 0).
+    """
+    n = len(PALETTE)
+    i = (int(index) % n + n) % n
+    return PALETTE[i]
+
+
+def prefix_line(name, line, width, color_code, use_color):
+    """Format one line of a child's output for our stdout::
+
+        web  | listening on :3000
+
+    The name is right-padded to ``width`` (the longest process name, so the
+    ``|`` separators line up) and, when ``use_color``, wrapped in the given ANSI
+    code. Padding is added BEFORE coloring so the visible columns stay aligned
+    and the escape sequences never count toward width. Pure: no globals, no IO.
+    """
+    padded = str(name).ljust(width)
+    label = f"\x1b[{color_code}m{padded}\x1b[0m" if use_color else padded
+    return f"{label} | {line}"

proctide-0.1.0/src/proctide/runner.py

@@ -0,0 +1,148 @@
+"""proctide runner — the IO half: spawn every process concurrently, prefix each
+line of their interleaved stdout/stderr, forward signals, and report exits.
+
+This module is deliberately NOT vector-tested: live interleaved process output is
+nondeterministic. It is behavior-aligned with the Node port (same Procfile ->
+same prefix format) and exercised by the integration smoke test instead. All the
+deterministic string work lives in core.py.
+"""
+
+import os
+import signal
+import subprocess
+import sys
+import threading
+import time
+
+from . import core
+
+
+def run(entries, color=False, out=None):
+    """Run a list of ``{"name", "cmd"}`` entries concurrently.
+
+    Returns the process exit code to use (non-zero if any child exited non-zero).
+    """
+    if out is None:
+        out = sys.stdout
+    if not entries:
+        return 0
+
+    width = max(len(e["name"]) for e in entries)
+    lock = threading.Lock()  # serialize writes so prefixed lines never tear
+    state = {"worst": 0, "shutting_down": False}
+    procs = []  # list of (entry, color_code, Popen)
+    posix = os.name == "posix"
+
+    def write(s):
+        with lock:
+            out.write(s)
+            out.flush()
+
+    def dim(s):
+        return f"\x1b[2m{s}\x1b[0m" if color else s
+
+    def emit(name, color_code, line):
+        write(core.prefix_line(name, line, width, color_code, color) + "\n")
+
+    def signal_proc(proc, sig):
+        if proc.poll() is not None:
+            return
+        # Signal the whole process group (start_new_session=True made the child a
+        # group leader), so a `sh -c 'sleep 30'` takes its `sleep` grandchild
+        # down too instead of orphaning it. Fall back to the direct child.
+        try:
+            if posix:
+                os.killpg(proc.pid, sig)
+            else:
+                proc.send_signal(sig)
+        except (ProcessLookupError, OSError):
+            try:
+                proc.send_signal(sig)
+            except (ProcessLookupError, OSError):
+                pass
+
+    def shutdown(sig=signal.SIGTERM):
+        if state["shutting_down"]:
+            return
+        state["shutting_down"] = True
+        for _e, _c, p in procs:
+            signal_proc(p, sig)
+
+    def reader(entry, color_code, proc):
+        # One thread per process; bufsize=1 + text gives us line-at-a-time reads.
+        for line in proc.stdout:
+            emit(entry["name"], color_code, line.rstrip("\n"))
+        proc.wait()
+        code = proc.returncode
+        if code is not None and code < 0:
+            shown = f"signal {signal.Signals(-code).name}"
+        else:
+            shown = f"code {code}"
+        write(dim(core.prefix_line(entry["name"], f"exited ({shown})", width, color_code, False)) + "\n")
+        with lock:
+            if code and code > state["worst"]:
+                state["worst"] = code
+        # A process that *crashes* on its own (non-zero, or killed by a signal we
+        # didn't send) tears the rest down too — the foreman/overmind contract
+        # for a dev stack. But a clean exit (code 0) is just a one-shot step
+        # finishing; it must NOT kill the long-running siblings, and the reader
+        # above has already drained this child's pipe to EOF before we get here.
+        if not state["shutting_down"] and code not in (0, None):
+            shutdown(signal.SIGTERM)
+
+    # ---- spawn everything ----
+    threads = []
+    for idx, entry in enumerate(entries):
+        color_code = core.color_for(idx)
+        popen_kwargs = dict(
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            bufsize=1,
+            universal_newlines=True,
+        )
+        if posix:
+            popen_kwargs["start_new_session"] = True  # own process group
+        try:
+            proc = subprocess.Popen(entry["cmd"], **popen_kwargs)
+        except OSError as e:
+            emit(entry["name"], color_code, f"proctide: failed to start: {e}")
+            with lock:
+                if state["worst"] == 0:
+                    state["worst"] = 1
+            continue
+        procs.append((entry, color_code, proc))
+        t = threading.Thread(target=reader, args=(entry, color_code, proc), daemon=True)
+        threads.append(t)
+        t.start()
+
+    # ---- forward signals from the foreground ----
+    def handle(signum, _frame):
+        name = signal.Signals(signum).name
+        sys.stderr.write(dim(f"\nproctide: {name} received, shutting down…") + "\n")
+        sys.stderr.flush()
+        shutdown(signal.SIGTERM)
+
+    old_int = signal.signal(signal.SIGINT, handle)
+    old_term = signal.signal(signal.SIGTERM, handle)
+
+    try:
+        for t in threads:
+            t.join()
+        # Backstop: if anything is still alive (ignored SIGTERM), SIGKILL it.
+        deadline = time.time() + 5
+        for _e, _c, p in procs:
+            remaining = max(0.0, deadline - time.time())
+            try:
+                p.wait(timeout=remaining)
+            except subprocess.TimeoutExpired:
+                signal_proc(p, signal.SIGKILL)
+                try:
+                    p.wait(timeout=2)
+                except subprocess.TimeoutExpired:
+                    pass
+    finally:
+        signal.signal(signal.SIGINT, old_int)
+        signal.signal(signal.SIGTERM, old_term)
+
+    return state["worst"]

proctide-0.1.0/src/proctide.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: proctide
+Version: 0.1.0
+Summary: Run every process in your Procfile at once in one terminal, each output line prefixed with a colored process name; a clean Ctrl-C shuts them all down. Like foreman/overmind but zero-dependency and dual-runtime — no Ruby, no tmux.
+Author: yyfjj
+License: MIT
+Project-URL: Homepage, https://github.com/jjdoor/proctide-py
+Project-URL: Repository, https://github.com/jjdoor/proctide-py
+Project-URL: Issues, https://github.com/jjdoor/proctide-py/issues
+Keywords: procfile,foreman,overmind,process,process-manager,concurrent,runner,dev,devtools,cli,monorepo
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# proctide
+
+**Run every process in your `Procfile` together, in one terminal.** Each output
+line is prefixed with a colored process name so you can tell `web` from `worker`
+from `css` at a glance — and a single Ctrl-C takes the whole lot down cleanly.
+
+Zero dependencies (pure Python stdlib). No Ruby. No tmux.
+
+```bash
+pipx run proctide
+```
+
+```
+web    | listening on http://localhost:3000
+worker | polling jobs queue…
+css    | rebuilt app.css in 42ms
+web    | GET /  200  11ms
+worker | processed job #1841
+^C
+proctide: SIGINT received, shutting down…
+web    | exited (signal SIGTERM)
+worker | exited (signal SIGTERM)
+css    | exited (signal SIGTERM)
+```
+
+## Why another Procfile runner?
+
+[foreman](https://github.com/ddollar/foreman) is the classic, but it's a **Ruby
+gem** — one more runtime to install on a Node/Python box.
+[overmind](https://github.com/DarthSim/overmind) is great but needs **tmux**.
+[`concurrently`](https://www.npmjs.com/package/concurrently) is excellent and
+mature — but it's an npm dependency, and you spell your processes out on the
+command line instead of in a checked-in `Procfile`.
+
+`proctide` is the small middle ground: a real `Procfile`, prefixed interleaved
+output, clean shutdown — and **nothing to install but the tool itself**, on
+whichever of Python or Node you already have.
+
+## Install
+
+```bash
+pipx run proctide          # no install, run on demand
+pip install proctide       # or install the `proctide` command
+```
+
+There's an identical Node build too: `npx proctide` / `npm i -g proctide`
+(see [proctide](https://github.com/jjdoor/proctide)). Both ports parse the same
+Procfile and print the same prefix format — their pure cores are tested against
+the same vectors.
+
+## The Procfile
+
+One process per line, `name: command`. Blank lines and `#` comments are ignored.
+The command runs through your shell, so pipes, `&&`, env vars, and globs all work.
+
+```Procfile
+# Procfile
+web:    python server.py
+worker: python worker.py
+css:    npx tailwindcss -i app.css -o public/app.css --watch
+```
+
+```bash
+proctide                 # runs ./Procfile
+proctide -f Procfile.dev # or point somewhere else
+```
+
+## Usage
+
+```bash
+proctide [options]
+```
+
+| Option | Description |
+| --- | --- |
+| `-f, --file <path>` | Procfile to read (default: `./Procfile`). |
+| `--no-color` | Disable the colored name prefixes (e.g. when piping to a file). |
+| `-h, --help` | Show help. |
+| `-v, --version` | Print version. |
+
+### Behavior
+
+- **Concurrent.** Every process starts at once; their stdout *and* stderr are
+  merged into one stream, each line tagged `name | …`. The name column is padded
+  to the longest process name so the `|` separators line up.
+- **Clean shutdown.** Ctrl-C (SIGINT) — or SIGTERM — forwards SIGTERM to every
+  child's process group, waits briefly, then exits. A child that ignores SIGTERM
+  gets SIGKILL as a backstop.
+- **One dies, all stop.** If any process exits on its own, the rest are shut down
+  too — that's the foreman/overmind contract for a dev stack.
+- **Honest exit code.** `proctide` exits non-zero if any child exited non-zero,
+  so it behaves in CI and `Makefile`s.
+
+## Design notes
+
+- **A pure core, an IO shell.** `parse_procfile`, `color_for`, and `prefix_line`
+  are pure functions — no spawn, no clock, no signals — which is what lets the
+  Python and Node ports be proven identical against one shared vector table. The
+  spawning/streaming/signal-forwarding lives in a separate runner module and is
+  covered by an integration smoke test instead (live output is nondeterministic).
+- **Prefixes align by construction.** The name is padded to `width` *before* any
+  ANSI color is applied, so the escape codes never throw off the columns.
+- **Zero dependencies.** Python uses `subprocess.Popen` + one reader thread per
+  process behind a shared lock so prefixed lines never interleave mid-line; Node
+  uses `child_process.spawn` + `readline`.
+
+## License
+
+MIT

proctide-0.1.0/src/proctide.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/proctide/__init__.py
+src/proctide/__main__.py
+src/proctide/cli.py
+src/proctide/core.py
+src/proctide/runner.py
+src/proctide.egg-info/PKG-INFO
+src/proctide.egg-info/SOURCES.txt
+src/proctide.egg-info/dependency_links.txt
+src/proctide.egg-info/entry_points.txt
+src/proctide.egg-info/top_level.txt
+tests/test_core.py

proctide-0.1.0/src/proctide.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

proctide-0.1.0/src/proctide.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+proctide = proctide.cli:main

proctide-0.1.0/src/proctide.egg-info/top_level.txt

@@ -0,0 +1 @@
+proctide

proctide-0.1.0/tests/test_core.py

@@ -0,0 +1,108 @@
+import pytest
+
+from proctide.core import parse_procfile, color_for, prefix_line, PALETTE
+
+ESC = "\x1b"
+
+# ===================================================================
+# SHARED VECTORS. The Node port (test/core.test.js) runs the exact same
+# three tables, so both languages are proven to agree byte-for-byte on
+# the pure functions. (The live runner is nondeterministic and gets a
+# separate integration smoke test, not vectors.)
+# ===================================================================
+
+# parse_procfile: text -> (entries, errors)
+PARSE_VECTORS = [
+    (
+        "basic two processes",
+        "web: node server.js\nworker: node worker.js",
+        [{"name": "web", "cmd": "node server.js"}, {"name": "worker", "cmd": "node worker.js"}],
+        [],
+    ),
+    (
+        "skips blanks and # comments",
+        "# my Procfile\n\nweb: rackup\n\n  # indented comment\njob: ./run\n",
+        [{"name": "web", "cmd": "rackup"}, {"name": "job", "cmd": "./run"}],
+        [],
+    ),
+    (
+        "trims name and command whitespace",
+        "   web   :    node   server.js   ",
+        [{"name": "web", "cmd": "node   server.js"}],
+        [],
+    ),
+    (
+        "command may contain extra colons",
+        "clock: sh -c 'echo time: now; sleep 1'",
+        [{"name": "clock", "cmd": "sh -c 'echo time: now; sleep 1'"}],
+        [],
+    ),
+    (
+        "line without a colon is an error",
+        "web: ok\nthis has no colon\njob: ok2",
+        [{"name": "web", "cmd": "ok"}, {"name": "job", "cmd": "ok2"}],
+        [{"line": 2, "text": "this has no colon", "reason": 'no colon (expected "name: command")'}],
+    ),
+    (
+        "empty name and empty command are errors",
+        ": nameless\nweb:   \nworker: real",
+        [{"name": "worker", "cmd": "real"}],
+        [
+            {"line": 1, "text": ": nameless", "reason": "empty process name"},
+            {"line": 2, "text": "web:", "reason": "empty command"},
+        ],
+    ),
+    (
+        "empty input yields no entries",
+        "",
+        [],
+        [],
+    ),
+]
+
+# color_for: index -> ANSI code (deterministic palette cycling).
+COLOR_VECTORS = [
+    (0, "36"),
+    (1, "32"),
+    (2, "33"),
+    (3, "34"),
+    (4, "35"),
+    (5, "96"),
+    (6, "92"),
+    (7, "93"),
+    (8, "36"),  # wraps
+    (9, "32"),
+]
+
+# prefix_line: (name, line, width, color_code, use_color) -> string
+PREFIX_VECTORS = [
+    ("pads name to width, no color", ("web", "listening on :3000", 6, "36", False), "web    | listening on :3000"),
+    ("longer name, no padding needed", ("worker", "job done", 6, "32", False), "worker | job done"),
+    ("name longer than width is not truncated", ("database", "ready", 3, "33", False), "database | ready"),
+    ("color wraps the padded name only", ("web", "up", 6, "36", True), f"{ESC}[36mweb   {ESC}[0m | up"),
+    ("empty line still gets a prefix", ("web", "", 3, "34", False), "web | "),
+    ("width zero pads nothing", ("x", "hi", 0, "35", False), "x | hi"),
+]
+
+
+@pytest.mark.parametrize("name,raw,entries,errors", PARSE_VECTORS, ids=[v[0] for v in PARSE_VECTORS])
+def test_parse_procfile(name, raw, entries, errors):
+    got_entries, got_errors = parse_procfile(raw)
+    assert got_entries == entries
+    assert got_errors == errors
+
+
+@pytest.mark.parametrize("index,expected", COLOR_VECTORS, ids=[str(v[0]) for v in COLOR_VECTORS])
+def test_color_for(index, expected):
+    assert color_for(index) == expected
+
+
+@pytest.mark.parametrize("name,args,expected", PREFIX_VECTORS, ids=[v[0] for v in PREFIX_VECTORS])
+def test_prefix_line(name, args, expected):
+    assert prefix_line(*args) == expected
+
+
+def test_palette_has_no_red():
+    # red reads as "error"; keep it out of the process palette
+    assert "31" not in PALETTE
+    assert "91" not in PALETTE