pnpm-dash 0.1.0

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org>

package/README.md

@@ -0,0 +1,14 @@
+# pnpm-dash
+
+pnpm-dash is a terminal-based user interface (TUI) for pnpm, designed to provide a quick and interactive way to manage your pnpm workspace and packages.
+
+## Usage
+
+```bash
+pnpm dlx pnpm-dash dev
+```
+
+- Navigate using arrow keys
+- Select packages to inspect logs or stop/start task
+- Press `CTRL+C` to quit
+- Optional `-F` param allows filtering packages by name, use * for wildcard and ! for exclusions

package/dist/cli.js

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+export function parseCLI() {
+    const program = new Command();
+    program
+        .name('pnpm-dash')
+        .description('A TUI dashboard for pnpm workspaces - run scripts across packages with a split-pane interface')
+        .version('0.1.0')
+        .argument('<script>', 'Script name to run across workspace packages (e.g., dev, start)')
+        .option('-F, --filter <pattern...>', 'Filter packages by name pattern, supports * for wildcard and ! for exclusions')
+        .parse();
+    const scriptName = program.args[0];
+    const options = program.opts();
+    if (!scriptName) {
+        console.error('Error: Script name is required');
+        console.error('Usage: pnpm-dash <script> [options]');
+        console.error('Example: pnpm-dash dev');
+        console.error('Example: pnpm-dash dev -F "*abc"');
+        console.error('Example: pnpm-dash dev -F "!*def"');
+        process.exit(1);
+    }
+    return { scriptName, options };
+}

package/dist/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { parseCLI } from './cli.js';
+import { discoverWorkspace, filterPackages } from './workspace.js';
+import { Runner } from './runner.js';
+import { Dashboard } from './ui/dashboard.js';
+async function main() {
+    const { scriptName, options } = parseCLI();
+    console.log(`Discovering pnpm workspace...`);
+    let root;
+    let packages;
+    try {
+        const workspace = await discoverWorkspace();
+        root = workspace.root;
+        packages = workspace.packages;
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+    const filtered = filterPackages(packages, scriptName, options.filter);
+    if (filtered.length === 0) {
+        const filterInfo = options.filter?.length
+            ? ` matching filters: ${options.filter.join(', ')}`
+            : '';
+        console.error(`No packages found with script "${scriptName}"${filterInfo}`);
+        process.exit(1);
+    }
+    console.log(`Found ${filtered.length} package(s) with "${scriptName}" script:`);
+    for (const pkg of filtered) {
+        console.log(`  - ${pkg.name}`);
+    }
+    console.log();
+    const runner = new Runner(scriptName);
+    const dashboard = new Dashboard(runner, filtered);
+    runner.start(filtered);
+    dashboard.start();
+    process.on('SIGINT', async () => await dashboard.quit());
+    process.on('SIGTERM', async () => await dashboard.quit());
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/runner.js

@@ -0,0 +1,118 @@
+import { execa } from 'execa';
+import { EventEmitter } from 'node:events';
+export class Runner extends EventEmitter {
+    states = new Map();
+    scriptName;
+    constructor(scriptName) {
+        super();
+        this.scriptName = scriptName;
+    }
+    getStates() {
+        return this.states;
+    }
+    start(packages) {
+        for (const pkg of packages) {
+            this.startPackage(pkg);
+        }
+    }
+    startPackage(pkg) {
+        let state = this.states.get(pkg.name);
+        if (state) {
+            if (state.subprocess && state.subprocess.exitCode == null) {
+                console.error(`${pkg.name} subprocess is still running`, state.subprocess.pid);
+                return;
+            }
+            state.status = 'running';
+        }
+        else {
+            state = {
+                package: pkg,
+                status: 'running',
+                subprocess: null,
+                logs: [],
+            };
+            this.states.set(pkg.name, state);
+        }
+        const subprocess = execa('pnpm', ['run', this.scriptName], {
+            cwd: pkg.path,
+            env: {
+                ...process.env,
+                FORCE_COLOR: '1',
+            },
+            all: true,
+            buffer: false,
+            reject: false,
+            cleanup: false,
+            detached: true,
+        });
+        state.subprocess = subprocess;
+        this.emit('start', pkg.name);
+        subprocess.all.on('data', (data) => {
+            const lines = data.toString().split('\n');
+            for (const line of lines) {
+                if (line) {
+                    state.logs.push(line);
+                    this.emit('log', pkg.name, line);
+                }
+            }
+        });
+        subprocess.then((result) => {
+            state.status = result.exitCode === 0 ? 'success' : 'error';
+            state.subprocess = null;
+            this.emit('exit', pkg.name, result.exitCode ?? null);
+        }).catch((error) => {
+            state.status = 'error';
+            state.logs.push(`Error: ${error.message}`);
+            state.subprocess = null;
+            this.emit('error', pkg.name, error);
+        });
+    }
+    killProcessGroup(pid, force = false) {
+        const signal = force ? 'SIGKILL' : 'SIGTERM';
+        try {
+            process.kill(-pid, signal);
+        }
+        catch {
+            // Negative pid will throw on windows, back to SIGTERM
+            try {
+                process.kill(pid, signal);
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    async restartPackage(packageName) {
+        const state = this.states.get(packageName);
+        if (!state)
+            return;
+        await this.stopPackage(packageName);
+        this.startPackage(state.package);
+    }
+    async restartAll() {
+        await this.stopAll();
+        for (const state of this.states.values()) {
+            this.startPackage(state.package);
+        }
+    }
+    async stopPackage(packageName) {
+        const state = this.states.get(packageName);
+        const subprocess = state?.subprocess;
+        if (!subprocess?.pid)
+            return;
+        const pid = subprocess.pid;
+        this.killProcessGroup(pid);
+        const forceKillTimeout = setTimeout(() => {
+            this.killProcessGroup(pid, true);
+        }, 2000);
+        try {
+            await subprocess;
+        }
+        finally {
+            clearTimeout(forceKillTimeout);
+        }
+    }
+    async stopAll() {
+        await Promise.all(Array.from(this.states.keys()).map((name) => this.stopPackage(name)));
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/dashboard.js

@@ -0,0 +1,147 @@
+import blessed from 'reblessed';
+import { createSidebar, updateSidebarItems } from './sidebar.js';
+import { createLogView, updateLogView, appendLog, toggleLogAutoScroll } from './logview.js';
+import { createStatusBar, updateStatusBar } from './statusbar.js';
+export class Dashboard {
+    screen;
+    sidebar;
+    logView;
+    statusBar;
+    runner;
+    state;
+    packageNames = [];
+    constructor(runner, packages) {
+        this.runner = runner;
+        this.packageNames = packages.map((p) => p.name);
+        this.state = {
+            packages: runner.getStates(),
+            selectedIndex: 0,
+            autoScroll: true,
+        };
+        this.screen = blessed.screen({
+            smartCSR: true,
+            title: 'pnpm-dash',
+            fullUnicode: true,
+        });
+        this.sidebar = createSidebar(this.screen);
+        this.logView = createLogView(this.screen, this.state.autoScroll);
+        this.statusBar = createStatusBar(this.screen);
+        this.setupKeyBindings();
+        this.setupRunnerEvents();
+    }
+    setupKeyBindings() {
+        this.screen.key(['S-q', 'C-c'], () => {
+            this.quit();
+        });
+        this.screen.key(['q'], () => {
+            this.stopSelected();
+        });
+        this.screen.key(['j', 'down'], () => {
+            this.selectNext();
+        });
+        this.screen.key(['k', 'up'], () => {
+            this.selectPrev();
+        });
+        this.screen.key(['r'], () => {
+            this.restartSelected();
+        });
+        this.screen.key(['S-r'], () => {
+            this.restartAll();
+        });
+        this.screen.key(['s'], () => {
+            this.toggleAutoScroll();
+        });
+        this.screen.key(['c'], () => {
+            this.clearSelected();
+        });
+    }
+    setupRunnerEvents() {
+        this.runner.on('start', (packageName) => {
+            this.refreshSidebar();
+            this.screen.render();
+        });
+        this.runner.on('log', (packageName, line) => {
+            appendLog(this.logView, this.getSelectedPackageName(), packageName, line);
+        });
+        this.runner.on('exit', (packageName, code) => {
+            this.refreshSidebar();
+            this.screen.render();
+        });
+        this.runner.on('error', (packageName, error) => {
+            this.refreshSidebar();
+            this.screen.render();
+        });
+    }
+    getSelectedPackageName() {
+        return this.packageNames[this.state.selectedIndex];
+    }
+    getSelectedState() {
+        const name = this.getSelectedPackageName();
+        return name ? this.state.packages.get(name) : undefined;
+    }
+    selectNext() {
+        if (this.state.selectedIndex < this.packageNames.length - 1) {
+            this.state.selectedIndex++;
+        }
+        else if (this.packageNames.length > 1) {
+            this.state.selectedIndex = 0;
+        }
+        this.refreshSidebar();
+        this.refreshLogView();
+    }
+    selectPrev() {
+        if (this.state.selectedIndex > 0) {
+            this.state.selectedIndex--;
+        }
+        else if (this.packageNames.length > 1) {
+            this.state.selectedIndex = this.packageNames.length - 1;
+        }
+        this.refreshSidebar();
+        this.refreshLogView();
+    }
+    clearSelected() {
+        const state = this.getSelectedState();
+        if (state) {
+            state.logs = [];
+            this.refreshLogView();
+        }
+    }
+    stopSelected() {
+        const name = this.getSelectedPackageName();
+        if (name) {
+            this.runner.stopPackage(name);
+        }
+    }
+    restartSelected() {
+        const name = this.getSelectedPackageName();
+        if (name) {
+            this.runner.restartPackage(name);
+        }
+    }
+    restartAll() {
+        this.runner.restartAll();
+    }
+    toggleAutoScroll() {
+        this.state.autoScroll = !this.state.autoScroll;
+        toggleLogAutoScroll(this.logView, this.state.autoScroll);
+        updateStatusBar(this.statusBar, this.state.autoScroll);
+        this.screen.render();
+    }
+    refreshSidebar() {
+        updateSidebarItems(this.sidebar, this.state.packages, this.state.selectedIndex);
+    }
+    refreshLogView() {
+        updateLogView(this.logView, this.getSelectedState());
+    }
+    async quit() {
+        await this.runner.stopAll();
+        this.screen.destroy();
+        process.exit(0);
+    }
+    start() {
+        this.refreshSidebar();
+        this.refreshLogView();
+        this.sidebar.focus();
+        this.screen.render();
+    }
+}

package/dist/ui/logview.js

@@ -0,0 +1,51 @@
+import blessed from 'reblessed';
+export function createLogView(screen, autoScroll) {
+    const logView = blessed.log({
+        parent: screen,
+        label: ' Logs ',
+        left: '25%',
+        top: 0,
+        width: '75%',
+        height: '100%-1',
+        border: {
+            type: 'line',
+        },
+        style: {
+            border: {
+                fg: 'blue',
+            },
+            label: {
+                fg: 'blue',
+            },
+        },
+        mouse: true,
+        scrollbar: {
+            ch: '│',
+        },
+        scrollOnInput: autoScroll,
+    });
+    return logView;
+}
+export function updateLogView(logView, state) {
+    if (!state) {
+        logView.setLabel(' Logs ');
+        logView.setContent('');
+        logView.setScroll(0);
+        return;
+    }
+    logView.setLabel(` Logs - ${state.package.name} `);
+    logView.setContent(state.logs.join('\n'));
+    logView.setScroll(0);
+}
+export function appendLog(logView, currentPackage, packageName, line) {
+    if (currentPackage !== packageName) {
+        return;
+    }
+    logView.add(line);
+}
+export function toggleLogAutoScroll(logView, autoScroll) {
+    logView.scrollOnInput = autoScroll;
+    if (autoScroll) {
+        logView.setScrollPerc(100);
+    }
+}

package/dist/ui/sidebar.js

@@ -0,0 +1,51 @@
+import blessed from 'reblessed';
+const STATUS_ICONS = {
+    idle: { icon: '○', color: 'gray' },
+    running: { icon: '●', color: 'green' },
+    success: { icon: '✓', color: 'blue' },
+    error: { icon: '✘', color: 'red' },
+};
+export function createSidebar(screen) {
+    const sidebar = blessed.list({
+        parent: screen,
+        label: ' Packages ',
+        left: 0,
+        top: 0,
+        width: '25%',
+        height: '100%-1',
+        border: {
+            type: 'line',
+        },
+        style: {
+            border: {
+                fg: 'blue',
+            },
+            selected: {
+                bg: 'blue',
+                fg: 'white',
+            },
+            item: {
+                fg: 'white',
+            },
+            label: {
+                fg: 'blue',
+            } // invalid type from @types/blessed :|
+        },
+        mouse: false,
+        scrollable: true,
+        scrollbar: {
+            ch: '│',
+        },
+        tags: true,
+    });
+    return sidebar;
+}
+export function updateSidebarItems(sidebar, states, selectedIndex) {
+    const items = [];
+    for (const [name, state] of states) {
+        const { icon, color } = STATUS_ICONS[state.status];
+        items.push(`{${color}-fg}${icon}{/${color}-fg} ${name}`);
+    }
+    sidebar.setItems(items);
+    sidebar.select(selectedIndex);
+}

package/dist/ui/statusbar.js

@@ -0,0 +1,23 @@
+import blessed from 'reblessed';
+export function createStatusBar(screen) {
+    const statusBar = blessed.box({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        width: '100%',
+        height: 1,
+        style: {
+            bg: 'blue',
+            fg: 'white',
+        },
+        tags: true,
+    });
+    updateStatusBar(statusBar, true);
+    return statusBar;
+}
+export function updateStatusBar(statusBar, autoScroll) {
+    const scrollStatus = autoScroll ? 'ON' : 'OFF';
+    statusBar.setContent(` {bold}Q{/bold}:exit  {bold}q{/bold}:quit task  {bold}r{/bold}:restart task ` +
+        ` {bold}R{/bold}:restart all  {bold}j/k{/bold}:navigate  {bold}c{/bold}:clear ` +
+        ` {bold}s{/bold}:autoscroll [${scrollStatus}]`);
+}

package/dist/workspace.js

@@ -0,0 +1,36 @@
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
+import { findWorkspacePackages } from '@pnpm/workspace.find-packages';
+export async function discoverWorkspace(cwd = process.cwd()) {
+    const workspaceRoot = await findWorkspaceDir(cwd);
+    if (!workspaceRoot) {
+        throw new Error('No pnpm workspace found. Make sure you have a pnpm-workspace.yaml file in your project root.');
+    }
+    const projects = await findWorkspacePackages(workspaceRoot);
+    const packages = projects
+        .filter((project) => project.manifest.name && project.rootDir !== workspaceRoot)
+        .map((project) => ({
+        name: project.manifest.name,
+        path: project.rootDir,
+        scripts: project.manifest.scripts || {},
+    }));
+    return { root: workspaceRoot, packages };
+}
+function globMatch(name, pattern) {
+    const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+    return regex.test(name);
+}
+export function filterPackages(packages, scriptName, filterPatterns) {
+    let targetPgks = packages.filter((pkg) => pkg.scripts[scriptName]);
+    if (!filterPatterns?.length) {
+        return targetPgks;
+    }
+    const includePatterns = filterPatterns.filter((p) => !p.startsWith('!'));
+    const excludePatterns = filterPatterns.filter((p) => p.startsWith('!')).map((p) => p.slice(1));
+    if (includePatterns.length > 0) {
+        targetPgks = targetPgks.filter((pkg) => includePatterns.some((pattern) => globMatch(pkg.name, pattern)));
+    }
+    if (excludePatterns.length > 0) {
+        targetPgks = targetPgks.filter((pkg) => !excludePatterns.some((pattern) => globMatch(pkg.name, pattern)));
+    }
+    return targetPgks;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "pnpm-dash",
+  "version": "0.1.0",
+  "description": "A TUI dashboard for pnpm workspaces - run scripts across packages with a split-pane interface",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "pnpm-dash": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node ./dist/index.js"
+  },
+  "keywords": [
+    "pnpm",
+    "monorepo",
+    "workspace",
+    "tui",
+    "dashboard",
+    "terminal"
+  ],
+  "author": "artygus",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@pnpm/find-workspace-dir": "^7.0.2",
+    "@pnpm/workspace.find-packages": "^4.0.5",
+    "commander": "^13.1.0",
+    "execa": "^9.6.1",
+    "reblessed": "^0.2.1"
+  },
+  "devDependencies": {
+    "@types/blessed": "^0.1.25",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}