@sebastianstoll/spup 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sebastian Stoll
+
+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,65 @@
+# spup (Spin Up)
+
+Holistic Laravel process manager with a tabbed TUI. One command to start everything (schedulers, queues, vite, and whatever you want).
+
+## Install
+
+```bash
+npm install -g spup
+```
+
+## Usage
+
+### Initialize
+
+```bash
+cd ~/projects/my-laravel-app
+spup init
+```
+
+Creates a `spup.json` with Laravel defaults (configure as needed):
+
+```json
+{
+  "name": "my-laravel-app",
+  "processes": [
+    { "name": "serve", "command": "php artisan serve" },
+    { "name": "vite", "command": "npm run dev" },
+    { "name": "queue", "command": "php artisan queue:work" },
+    { "name": "logs", "command": "tail -f storage/logs/laravel.log" },
+    { "name": "schedule", "command": "php artisan schedule:work" }
+  ]
+}
+```
+
+### Start
+
+```bash
+spup start
+```
+
+Opens a full-screen tabbed UI where each process has its own tab with dedicated output.
+
+### Navigation
+
+| Key | Action |
+|-----|--------|
+| `1`-`9` | Switch to tab by number |
+| `Tab` | Next tab |
+| `Shift+Tab` | Previous tab |
+| `↑` / `↓` | Scroll output |
+| `PgUp` / `PgDn` | Scroll by page |
+| `q` / `Ctrl+C` | Quit all processes |
+
+## Configuration
+
+Edit `spup.json` to customize. Each process supports:
+
+- `name` — Tab label
+- `command` — The command to run
+- `cwd` — Working directory (optional)
+- `env` — Environment variables (optional)
+
+## License
+
+MIT

package/bin/spup.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../src/cli.js';
+
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@sebastianstoll/spup",
+  "version": "0.1.0",
+  "description": "Laravel process manager with a tabbed TUI.",
+  "type": "module",
+  "bin": {
+    "spup": "bin/spup.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "keywords": [
+    "cli",
+    "laravel",
+    "process-manager",
+    "tui",
+    "dev"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.js

@@ -0,0 +1,42 @@
+import { init } from './commands/init.js';
+import { start } from './commands/start.js';
+
+const HELP = `
+spup - Laravel process manager with a tabbed TUI.
+
+Usage:
+  spup init    Initialize spup.json with Laravel defaults
+  spup start   Start all processes in a tabbed terminal UI
+  spup help    Show this help message
+
+Examples:
+  spup init
+  spup start
+
+Navigation (during spup start):
+  1-9          Switch to tab by number
+  Tab          Next tab
+  Shift+Tab    Previous tab
+  q / Ctrl+C   Quit
+`;
+
+export function run(args) {
+  const command = args[0];
+
+  switch (command) {
+    case 'init':
+      return init();
+    case 'start':
+      return start();
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      console.log(HELP);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log('Run "spup help" for usage.');
+      process.exit(1);
+  }
+}

package/src/colors.js

@@ -0,0 +1,14 @@
+// Minimal ANSI color helpers — zero dependencies
+
+const esc = (code) => (str) => `\x1b[${code}m${str}\x1b[0m`;
+
+export const colors = {
+  red: esc('31'),
+  green: esc('32'),
+  yellow: esc('33'),
+  blue: esc('34'),
+  magenta: esc('35'),
+  cyan: esc('36'),
+  dim: esc('2'),
+  bold: esc('1'),
+};

package/src/commands/init.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { colors } from '../colors.js';
+
+const DEFAULT_PROCESSES = [
+  { name: 'serve', command: 'php artisan serve' },
+  { name: 'vite', command: 'npm run dev' },
+  { name: 'queue', command: 'php artisan queue:work' },
+  { name: 'logs', command: 'tail -f storage/logs/laravel.log' },
+  { name: 'schedule', command: 'php artisan schedule:work' },
+];
+
+export function init() {
+  const targetPath = path.join(process.cwd(), 'spup.json');
+
+  if (fs.existsSync(targetPath)) {
+    console.error(colors.yellow('spup.json already exists in this directory.'));
+    console.log('Delete it first if you want to re-initialize.');
+    process.exit(1);
+  }
+
+  // Check if this looks like a Laravel project
+  const artisanExists = fs.existsSync(path.join(process.cwd(), 'artisan'));
+  if (!artisanExists) {
+    console.error(colors.yellow('Warning: No artisan file found. Are you in a Laravel project?'));
+  }
+
+  const projectName = path.basename(process.cwd());
+
+  const config = {
+    name: projectName,
+    processes: DEFAULT_PROCESSES,
+  };
+
+  fs.writeFileSync(targetPath, JSON.stringify(config, null, 2) + '\n');
+
+  console.log(colors.green('Initialized spup.json'));
+  console.log('');
+  console.log('Processes:');
+  for (const proc of config.processes) {
+    console.log(`  ${colors.cyan(proc.name.padEnd(12))} ${proc.command}`);
+  }
+  console.log('');
+  console.log(`Edit spup.json to add/remove processes, then run ${colors.bold('spup start')}.`);
+}

package/src/commands/start.js

@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { TUI } from '../tui.js';
+
+export function start() {
+  const configPath = path.join(process.cwd(), 'spup.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.error('No spup.json found. Run "spup init" first.');
+    process.exit(1);
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  } catch {
+    console.error('Failed to parse spup.json.');
+    process.exit(1);
+  }
+
+  if (!config.processes || config.processes.length === 0) {
+    console.error('No processes defined in spup.json.');
+    process.exit(1);
+  }
+
+  const tabs = config.processes.map((proc) => ({
+    name: proc.name,
+    command: proc.command,
+    buffer: [],
+    status: 'starting',
+  }));
+
+  const tui = new TUI(tabs);
+  const children = [];
+
+  for (let i = 0; i < config.processes.length; i++) {
+    const proc = config.processes[i];
+
+    const child = spawn(proc.command, {
+      shell: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: proc.cwd ? path.resolve(proc.cwd) : process.cwd(),
+      env: { ...process.env, ...(proc.env || {}), FORCE_COLOR: '1' },
+    });
+
+    const handleData = (data) => {
+      tui.appendToTab(i, data.toString());
+    };
+
+    child.stdout.on('data', handleData);
+    child.stderr.on('data', handleData);
+
+    child.on('spawn', () => {
+      tui.setTabStatus(i, 'running');
+    });
+
+    child.on('error', (err) => {
+      tui.appendToTab(i, `Error: ${err.message}`);
+      tui.setTabStatus(i, 'stopped');
+    });
+
+    child.on('exit', (code) => {
+      tui.appendToTab(i, code === 0 ? 'Process exited.' : `Process exited with code ${code}.`);
+      tui.setTabStatus(i, 'stopped');
+    });
+
+    children.push(child);
+  }
+
+  const shutdown = () => {
+    tui.stop();
+    for (const child of children) {
+      if (child.exitCode === null) {
+        child.kill('SIGTERM');
+      }
+    }
+    setTimeout(() => process.exit(0), 2000);
+  };
+
+  tui.onQuit = shutdown;
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  tui.start();
+}

package/src/tui.js

@@ -0,0 +1,243 @@
+const ESC = '\x1b[';
+
+const ansi = {
+  enterAlt: '\x1b[?1049h',
+  leaveAlt: '\x1b[?1049l',
+  clearScreen: `${ESC}2J`,
+  hideCursor: `${ESC}?25l`,
+  showCursor: `${ESC}?25h`,
+  moveTo: (row, col) => `${ESC}${row};${col}H`,
+  clearLine: `${ESC}K`,
+  reset: `${ESC}0m`,
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  inverse: `${ESC}7m`,
+  fg: {
+    black: `${ESC}30m`,
+    white: `${ESC}37m`,
+    cyan: `${ESC}36m`,
+    yellow: `${ESC}33m`,
+    green: `${ESC}32m`,
+    red: `${ESC}31m`,
+    gray: `${ESC}90m`,
+  },
+  bg: {
+    black: `${ESC}40m`,
+    white: `${ESC}47m`,
+    cyan: `${ESC}46m`,
+    gray: `${ESC}100m`,
+  },
+};
+
+export class TUI {
+  constructor(tabs) {
+    this.tabs = tabs; // [{ name, buffer: string[] }]
+    this.activeTab = 0;
+    this.scrollOffset = 0; // lines from bottom (0 = follow tail)
+    this.cols = process.stdout.columns || 80;
+    this.rows = process.stdout.rows || 24;
+  }
+
+  start() {
+    process.stdout.write(ansi.enterAlt + ansi.hideCursor + ansi.clearScreen);
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', (data) => this.handleInput(data));
+
+    process.stdout.on('resize', () => {
+      this.cols = process.stdout.columns;
+      this.rows = process.stdout.rows;
+      this.render();
+    });
+
+    this.render();
+  }
+
+  stop() {
+    process.stdout.write(ansi.showCursor + ansi.leaveAlt);
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+  }
+
+  appendToTab(index, text) {
+    const lines = text.split('\n');
+    for (const line of lines) {
+      if (line !== '') {
+        this.tabs[index].buffer.push(line);
+        // Keep buffer at a reasonable size
+        if (this.tabs[index].buffer.length > 5000) {
+          this.tabs[index].buffer.splice(0, 1000);
+        }
+      }
+    }
+    if (index === this.activeTab) {
+      this.render();
+    }
+  }
+
+  setTabStatus(index, status) {
+    this.tabs[index].status = status;
+    this.render();
+  }
+
+  handleInput(data) {
+    const key = data.toString();
+
+    // Ctrl+C or q
+    if (key === '\x03' || key === 'q') {
+      this.onQuit?.();
+      return;
+    }
+
+    // Tab key
+    if (key === '\t') {
+      this.activeTab = (this.activeTab + 1) % this.tabs.length;
+      this.scrollOffset = 0;
+      this.render();
+      return;
+    }
+
+    // Shift+Tab
+    if (key === '\x1b[Z') {
+      this.activeTab = (this.activeTab - 1 + this.tabs.length) % this.tabs.length;
+      this.scrollOffset = 0;
+      this.render();
+      return;
+    }
+
+    // Number keys 1-9
+    const num = parseInt(key);
+    if (num >= 1 && num <= this.tabs.length) {
+      this.activeTab = num - 1;
+      this.scrollOffset = 0;
+      this.render();
+      return;
+    }
+
+    // Arrow up / scroll up
+    if (key === '\x1b[A' || key === 'k') {
+      const tab = this.tabs[this.activeTab];
+      const contentHeight = this.rows - 4; // tab bar + status bar + borders
+      const maxScroll = Math.max(0, tab.buffer.length - contentHeight);
+      this.scrollOffset = Math.min(this.scrollOffset + 1, maxScroll);
+      this.render();
+      return;
+    }
+
+    // Arrow down / scroll down
+    if (key === '\x1b[B' || key === 'j') {
+      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+      this.render();
+      return;
+    }
+
+    // Page up
+    if (key === '\x1b[5~') {
+      const tab = this.tabs[this.activeTab];
+      const contentHeight = this.rows - 4;
+      const maxScroll = Math.max(0, tab.buffer.length - contentHeight);
+      this.scrollOffset = Math.min(this.scrollOffset + contentHeight, maxScroll);
+      this.render();
+      return;
+    }
+
+    // Page down
+    if (key === '\x1b[6~') {
+      const contentHeight = this.rows - 4;
+      this.scrollOffset = Math.max(0, this.scrollOffset - contentHeight);
+      this.render();
+      return;
+    }
+
+    // Home — scroll to top
+    if (key === '\x1b[H' || key === 'g') {
+      const tab = this.tabs[this.activeTab];
+      const contentHeight = this.rows - 4;
+      this.scrollOffset = Math.max(0, tab.buffer.length - contentHeight);
+      this.render();
+      return;
+    }
+
+    // End — scroll to bottom
+    if (key === '\x1b[F' || key === 'G') {
+      this.scrollOffset = 0;
+      this.render();
+      return;
+    }
+  }
+
+  render() {
+    const out = [];
+    out.push(ansi.moveTo(1, 1));
+
+    // Tab bar
+    out.push(this.renderTabBar());
+
+    // Separator
+    out.push(ansi.moveTo(2, 1));
+    out.push(ansi.fg.gray + '─'.repeat(this.cols) + ansi.reset);
+
+    // Content area
+    const contentHeight = this.rows - 4;
+    const tab = this.tabs[this.activeTab];
+    const buffer = tab.buffer;
+
+    const end = buffer.length - this.scrollOffset;
+    const start = Math.max(0, end - contentHeight);
+    const visible = buffer.slice(start, end);
+
+    for (let i = 0; i < contentHeight; i++) {
+      out.push(ansi.moveTo(i + 3, 1));
+      out.push(ansi.clearLine);
+      if (i < visible.length) {
+        const line = visible[i];
+        // Truncate to terminal width (accounting for ANSI codes is hard, so just cap it)
+        out.push(line.length > this.cols ? line.substring(0, this.cols) : line);
+      }
+    }
+
+    // Bottom separator
+    out.push(ansi.moveTo(this.rows - 1, 1));
+    out.push(ansi.fg.gray + '─'.repeat(this.cols) + ansi.reset);
+
+    // Status bar
+    out.push(ansi.moveTo(this.rows, 1));
+    out.push(ansi.clearLine);
+    out.push(this.renderStatusBar());
+
+    process.stdout.write(out.join(''));
+  }
+
+  renderTabBar() {
+    let bar = '';
+    for (let i = 0; i < this.tabs.length; i++) {
+      const tab = this.tabs[i];
+      const label = ` ${i + 1}:${tab.name} `;
+
+      if (i === this.activeTab) {
+        bar += `${ansi.bold}${ansi.inverse}${label}${ansi.reset}`;
+      } else {
+        const statusColor = tab.status === 'running' ? ansi.fg.green
+          : tab.status === 'stopped' ? ansi.fg.red
+          : ansi.fg.gray;
+        bar += `${statusColor}${label}${ansi.reset}`;
+      }
+      bar += ' ';
+    }
+    return bar + ansi.clearLine;
+  }
+
+  renderStatusBar() {
+    const tab = this.tabs[this.activeTab];
+    const status = tab.status || 'starting';
+    const statusColor = status === 'running' ? ansi.fg.green
+      : status === 'stopped' ? ansi.fg.red
+      : ansi.fg.yellow;
+
+    const left = `${statusColor}● ${status}${ansi.reset} ${ansi.dim}${tab.command}${ansi.reset}`;
+    const right = `${ansi.dim}Tab/1-${this.tabs.length}: switch  ↑↓: scroll  q: quit${ansi.reset}`;
+
+    return left + ansi.clearLine + ansi.moveTo(this.rows, Math.max(1, this.cols - 45)) + right;
+  }
+}