@aerode/pish 0.8.0

package/dist/render.js

@@ -0,0 +1,455 @@
+/**
+ * Renderer — UI output for pish.
+ *
+ * Uses pi-tui components (Box, Text, Markdown) for block rendering.
+ * All output goes to process.stderr.
+ */
+import { Box, Markdown, Text, visibleWidth, } from '@mariozechner/pi-tui';
+import { bold, createMarkdownTheme, dim, TAG, theme, toolBg } from './theme.js';
+// ─── Banner / Exit / Control ───
+export function printBanner(cfg) {
+    if (cfg.noBanner)
+        return;
+    const parts = [`v${cfg.version}`, dim(cfg.shell)];
+    if (cfg.noAgent)
+        parts.push(theme.warning('no-agent'));
+    process.stderr.write(`${TAG} ${parts.join(dim(' │ '))}\n`);
+}
+export function printExit() {
+    process.stderr.write(`${TAG} ${dim('session ended')}\n`);
+}
+export function printControl(cmd) {
+    process.stderr.write(`${TAG} ${dim(cmd)}\n`);
+}
+/** Render control command result (success or error). */
+export function printControlResult(cmd, response) {
+    const name = cmd.trim().split(/\s+/)[0];
+    if (!response.success) {
+        const err = response.error ?? 'unknown error';
+        process.stderr.write(`${TAG} ${theme.error('✗')} ${dim(name)}: ${err}\n`);
+        return;
+    }
+    const d = response.data;
+    switch (response.command) {
+        case 'set_model': {
+            const prov = d?.provider;
+            const provider = typeof prov === 'object' && prov !== null
+                ? (prov.id ?? '')
+                : String(prov ?? '');
+            const modelId = d?.id ?? d?.modelId ?? '';
+            process.stderr.write(`${TAG} ${theme.success('✓')} model → ${provider ? `${provider} ` : ''}${theme.accent(modelId)}\n`);
+            break;
+        }
+        case 'set_thinking_level': {
+            const arg = cmd.trim().split(/\s+/).slice(1).join(' ') || 'medium';
+            process.stderr.write(`${TAG} ${theme.success('✓')} thinking → ${theme.accent(arg)}\n`);
+            break;
+        }
+        case 'compact': {
+            if (d?.tokensBefore) {
+                process.stderr.write(`${TAG} ${theme.success('✓')} compacted ${formatCompact(d.tokensBefore)} tokens\n`);
+            }
+            else {
+                process.stderr.write(`${TAG} ${theme.success('✓')} compacted\n`);
+            }
+            break;
+        }
+        default:
+            process.stderr.write(`${TAG} ${theme.success('✓')} ${dim(name)}\n`);
+    }
+}
+export function printNotice(msg) {
+    process.stderr.write(`${TAG} ${theme.warning('⚠')} ${msg}\n`);
+}
+// ─── Spinner ───
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function startSpinner(label) {
+    let frame = 0;
+    let stopped = false;
+    const maxLabelCols = termWidth() - 3;
+    let truncLabel = label;
+    if (visibleWidth(label) > maxLabelCols) {
+        while (visibleWidth(truncLabel) > maxLabelCols - 3 &&
+            truncLabel.length > 0) {
+            truncLabel = truncLabel.slice(0, -1);
+        }
+        truncLabel += '...';
+    }
+    const render = () => {
+        const f = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+        process.stderr.write(`\r${theme.accent(f)} ${theme.muted(truncLabel)}`);
+        frame++;
+    };
+    render();
+    const timer = setInterval(render, 80);
+    return () => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(timer);
+        process.stderr.write('\r\x1b[2K');
+    };
+}
+// ─── Helpers ───
+function termWidth() {
+    return process.stderr.columns || 80;
+}
+function flush(comp) {
+    for (const line of comp.render(termWidth())) {
+        process.stderr.write(`${line}\n`);
+    }
+}
+function shortenPath(p) {
+    const home = process.env.HOME;
+    if (home && p.startsWith(home))
+        return `~${p.slice(home.length)}`;
+    return p;
+}
+function truncate(s, max) {
+    const flat = s.replace(/\n/g, ' ');
+    if (flat.length <= max)
+        return flat;
+    return `${flat.slice(0, max - 3)}...`;
+}
+// ─── Tool title (matching pi's per-tool renderCall) ───
+function formatToolTitle(toolName, args) {
+    if (toolName === 'bash' && typeof args.command === 'string') {
+        return `$ ${args.command}`;
+    }
+    if (toolName === 'read' && typeof args.path === 'string') {
+        const p = shortenPath(args.path);
+        const offset = args.offset;
+        const limit = args.limit;
+        let display = `read ${theme.accent(p)}`;
+        if (offset !== undefined || limit !== undefined) {
+            const start = offset ?? 1;
+            const end = limit !== undefined ? start + limit - 1 : '';
+            display += theme.warning(`:${start}${end ? `-${end}` : ''}`);
+        }
+        return display;
+    }
+    if (toolName === 'write' && typeof args.path === 'string') {
+        return `write ${theme.accent(shortenPath(args.path))}`;
+    }
+    if (toolName === 'edit' && typeof args.path === 'string') {
+        return `edit ${theme.accent(shortenPath(args.path))}`;
+    }
+    const keys = Object.keys(args);
+    if (keys.length > 0)
+        return `${toolName} ${truncate(String(args[keys[0]]), 60)}`;
+    return toolName;
+}
+function extractResultText(result) {
+    if (!result || typeof result !== 'object')
+        return '';
+    const r = result;
+    if (Array.isArray(r.content)) {
+        const texts = [];
+        for (const item of r.content) {
+            if (item && typeof item === 'object') {
+                const rec = item;
+                if (rec.type === 'text' && typeof rec.text === 'string') {
+                    texts.push(rec.text);
+                }
+            }
+        }
+        return texts.join('\n').trim();
+    }
+    if (typeof r.text === 'string')
+        return r.text;
+    if (typeof r.output === 'string')
+        return r.output;
+    return '';
+}
+// ─── Status bar (pi footer style) ───
+function formatCompact(n) {
+    if (n < 1000)
+        return n.toString();
+    if (n < 10000)
+        return `${(n / 1000).toFixed(1)}k`;
+    if (n < 1000000)
+        return `${Math.round(n / 1000)}k`;
+    if (n < 10000000)
+        return `${(n / 1000000).toFixed(1)}M`;
+    return `${Math.round(n / 1000000)}M`;
+}
+function renderStatusBar(durationMs, usage) {
+    const w = termWidth();
+    const t = (durationMs / 1000).toFixed(1);
+    if (!usage || usage.totalTokens === 0) {
+        process.stderr.write(`${theme.success('✓')} done (${t}s)\n`);
+        return;
+    }
+    const parts = [];
+    if (usage.inputTokens)
+        parts.push(`↑${formatCompact(usage.inputTokens)}`);
+    if (usage.outputTokens)
+        parts.push(`↓${formatCompact(usage.outputTokens)}`);
+    if (usage.cacheRead)
+        parts.push(`R${formatCompact(usage.cacheRead)}`);
+    if (usage.cacheWrite)
+        parts.push(`W${formatCompact(usage.cacheWrite)}`);
+    if (usage.cost > 0)
+        parts.push(`$${usage.cost.toFixed(3)}`);
+    if (usage.contextWindow > 0) {
+        const windowStr = formatCompact(usage.contextWindow);
+        if (usage.contextPercent !== null) {
+            parts.push(`${usage.contextPercent.toFixed(1)}%/${windowStr}`);
+        }
+        else {
+            parts.push(`/${windowStr}`);
+        }
+    }
+    parts.push(`${t}s`);
+    const leftContent = parts.join(' ');
+    const rightParts = [];
+    if (usage.provider)
+        rightParts.push(`(${usage.provider})`);
+    if (usage.model) {
+        let modelStr = usage.model;
+        if (usage.thinkingLevel)
+            modelStr += ` • ${usage.thinkingLevel}`;
+        rightParts.push(modelStr);
+    }
+    const rightContent = rightParts.join(' ');
+    const leftLen = leftContent.length;
+    const rightLen = rightContent.length;
+    const minPad = 2;
+    let line;
+    if (leftLen + minPad + rightLen <= w) {
+        const pad = ' '.repeat(w - leftLen - rightLen);
+        line = leftContent + pad + rightContent;
+    }
+    else if (leftLen + minPad <= w) {
+        const avail = w - leftLen - minPad;
+        const truncRight = rightContent.slice(0, avail);
+        const pad = ' '.repeat(w - leftLen - truncRight.length);
+        line = leftContent + pad + truncRight;
+    }
+    else {
+        line = leftContent;
+    }
+    process.stderr.write(`${theme.dim(line)}\n`);
+}
+// ─── StreamRenderer ───
+export class StreamRenderer {
+    inThinking = false;
+    inText = false;
+    textAccum = '';
+    stopSpinner = null;
+    mdTheme;
+    pendingTools = new Map();
+    toolResultLines;
+    constructor(toolResultLines = 10) {
+        this.mdTheme = createMarkdownTheme();
+        this.toolResultLines = toolResultLines;
+    }
+    handleEvent(event) {
+        switch (event.type) {
+            case 'thinking_start':
+                this.onThinkingStart();
+                break;
+            case 'thinking_delta':
+                this.onThinkingDelta(event.delta);
+                break;
+            case 'thinking_end':
+                this.onThinkingEnd();
+                break;
+            case 'text_start':
+                this.onTextStart();
+                break;
+            case 'text_delta':
+                this.onTextDelta(event.delta);
+                break;
+            case 'text_end':
+                this.onTextEnd();
+                break;
+            case 'tool_start':
+                this.onToolStart(event.toolCallId, event.toolName, event.args);
+                break;
+            case 'tool_update':
+                break;
+            case 'tool_end':
+                this.onToolEnd(event.toolCallId, event.toolName, event.result, event.isError);
+                break;
+            case 'turn_end':
+                break;
+            case 'compaction_start':
+                this.onCompactionStart(event.reason);
+                break;
+            case 'compaction_end':
+                this.onCompactionEnd(event.summary, event.aborted, event.error);
+                break;
+            case 'agent_done':
+                this.onDone(event.durationMs, event.usage);
+                break;
+            case 'agent_error':
+                this.onError(event.error);
+                break;
+        }
+    }
+    showSpinner() {
+        process.stderr.write('\x1b[?25l'); // hide cursor
+        this.stopSpinner = startSpinner('Working...');
+    }
+    // ─── Thinking ───
+    onThinkingStart() {
+        this.clearSpinner();
+        this.inThinking = true;
+        process.stderr.write('\n');
+    }
+    onThinkingDelta(delta) {
+        if (!this.inThinking)
+            return;
+        process.stderr.write(theme.thinkingText(delta));
+    }
+    onThinkingEnd() {
+        if (!this.inThinking)
+            return;
+        this.inThinking = false;
+        process.stderr.write('\n');
+        this.restartSpinner();
+    }
+    // ─── Text ───
+    onTextStart() {
+        this.clearSpinner();
+        this.inText = true;
+        this.textAccum = '';
+        process.stderr.write('\n');
+    }
+    onTextDelta(delta) {
+        if (!this.inText)
+            return;
+        this.textAccum += delta;
+        process.stderr.write(delta);
+    }
+    onTextEnd() {
+        if (!this.inText)
+            return;
+        this.inText = false;
+        const raw = this.textAccum.trim();
+        if (!raw) {
+            const linesToErase = this.countCursorLinesFromStart(this.textAccum);
+            if (linesToErase > 0) {
+                process.stderr.write(`\x1b[${linesToErase}A`);
+            }
+            process.stderr.write('\x1b[1G\x1b[0J');
+            this.textAccum = '';
+            return;
+        }
+        const linesToErase = this.countCursorLinesFromStart(this.textAccum);
+        if (linesToErase > 0) {
+            process.stderr.write(`\x1b[${linesToErase}A`);
+        }
+        process.stderr.write('\x1b[1G\x1b[0J');
+        const md = new Markdown(raw, 1, 0, this.mdTheme);
+        flush(md);
+        this.textAccum = '';
+        this.restartSpinner();
+    }
+    // ─── Tool calls ───
+    onToolStart(toolCallId, toolName, args) {
+        this.clearSpinner();
+        const title = formatToolTitle(toolName, args);
+        this.pendingTools.set(toolCallId, title);
+        this.stopSpinner = startSpinner(title);
+    }
+    onToolEnd(toolCallId, _toolName, result, isError) {
+        this.clearSpinner();
+        const title = this.pendingTools.get(toolCallId) || '';
+        this.pendingTools.delete(toolCallId);
+        const bgFunc = isError ? toolBg.error : toolBg.success;
+        const text = extractResultText(result);
+        const box = new Box(1, 1, bgFunc);
+        box.addChild(new Text(bold(title), 0, 0));
+        if (text) {
+            const allLines = text.split('\n');
+            const display = allLines.length > this.toolResultLines
+                ? [
+                    ...allLines.slice(0, this.toolResultLines),
+                    theme.muted(`  ... (${allLines.length - this.toolResultLines} more lines)`),
+                ].join('\n')
+                : text;
+            box.addChild(new Text(theme.toolOutput(display), 0, 0));
+        }
+        else if (isError) {
+            box.addChild(new Text(theme.error('(error)'), 0, 0));
+        }
+        process.stderr.write('\n');
+        flush(box);
+        this.restartSpinner();
+    }
+    // ─── Auto-compaction ───
+    onCompactionStart(reason) {
+        this.clearSpinner();
+        const reasonText = reason === 'overflow'
+            ? 'Context overflow — auto-compacting...'
+            : 'Auto-compacting...';
+        this.stopSpinner = startSpinner(reasonText);
+    }
+    onCompactionEnd(summary, aborted, error) {
+        this.clearSpinner();
+        if (aborted) {
+            process.stderr.write(`${theme.warning('⚠')} compaction cancelled\n`);
+        }
+        else if (error) {
+            process.stderr.write(`${theme.error('✗')} compaction failed: ${error}\n`);
+        }
+        else if (summary) {
+            const short = summary.length > 80 ? `${summary.slice(0, 77)}...` : summary;
+            process.stderr.write(`${theme.accent('●')} compacted: ${theme.muted(short)}\n`);
+        }
+    }
+    // ─── Done / Error / Interrupted ───
+    showCursor() {
+        process.stderr.write('\x1b[?25h');
+    }
+    onDone(durationMs, usage) {
+        this.clearSpinner();
+        this.showCursor();
+        process.stderr.write('\n');
+        renderStatusBar(durationMs, usage);
+        process.stderr.write('\n');
+    }
+    onError(msg) {
+        this.clearSpinner();
+        this.showCursor();
+        process.stderr.write(`\n ${theme.error(`Error: ${msg}`)}\n\n`);
+    }
+    printInterrupted() {
+        this.clearSpinner();
+        this.showCursor();
+        if (this.inThinking) {
+            process.stderr.write('\n');
+            this.inThinking = false;
+        }
+        if (this.inText) {
+            process.stderr.write('\n');
+            this.inText = false;
+        }
+        process.stderr.write(`\n ${theme.error('Operation aborted')}\n\n`);
+    }
+    // ─── Internal ───
+    clearSpinner() {
+        if (this.stopSpinner) {
+            this.stopSpinner();
+            this.stopSpinner = null;
+        }
+    }
+    restartSpinner() {
+        this.stopSpinner = startSpinner('Working...');
+    }
+    countCursorLinesFromStart(text) {
+        const w = termWidth();
+        const segments = text.split('\n');
+        const newlineCount = segments.length - 1;
+        let wrapExtra = 0;
+        for (const seg of segments) {
+            const cols = visibleWidth(seg);
+            if (cols > w) {
+                wrapExtra += Math.ceil(cols / w) - 1;
+            }
+        }
+        return newlineCount + wrapExtra;
+    }
+}

package/dist/strip.js

@@ -0,0 +1,46 @@
+/**
+ * ANSI stripping + line-level truncation + alt screen detection.
+ *
+ * Used for the output segment (C→D).
+ */
+// Matches all ANSI escape sequences (CSI, OSC, ESC single-char, etc.)
+// and control chars: \x08 (BS), \x0d (CR), \x00-\x1f except \x0a (LF)
+const ANSI_RE = /\x1b(?:\[[0-9;?]*[a-zA-Z@`]|\][^\x07]*(?:\x07|\x1b\\)|\([A-Z0-9]|[=>DEHMNOPZ78])|[\x00-\x09\x0b-\x0d\x0e-\x1f\x7f]/g;
+/** Alt screen enter: \e[?1049h, \e[?47h, \e[?1047h */
+const ALT_SCREEN_RE = /\x1b\[\?(1049|47|1047)h/;
+export function isAltScreen(data) {
+    return ALT_SCREEN_RE.test(data);
+}
+export function stripAnsi(data) {
+    return data.replace(ANSI_RE, '');
+}
+export const DEFAULT_TRUNCATE = {
+    headLines: 50,
+    tailLines: 30,
+    maxLineWidth: 512,
+};
+/**
+ * Line-level truncation: keep head + tail lines, truncate the middle.
+ * Also truncates individual long lines.
+ *
+ * Head > tail ratio: command output typically starts with structured info
+ * (headers, column names, first results); tail preserves errors and final results.
+ */
+export function truncateLines(text, opts = DEFAULT_TRUNCATE) {
+    let lines = text.split('\n');
+    // Per-line truncation
+    lines = lines.map((line) => {
+        if (line.length > opts.maxLineWidth) {
+            return `${line.slice(0, opts.maxLineWidth)} ...`;
+        }
+        return line;
+    });
+    const total = lines.length;
+    const max = opts.headLines + opts.tailLines;
+    if (total <= max)
+        return lines.join('\n');
+    const head = lines.slice(0, opts.headLines);
+    const tail = lines.slice(-opts.tailLines);
+    const omitted = total - max;
+    return [...head, `... (${omitted} lines truncated) ...`, ...tail].join('\n');
+}

package/dist/theme.js

@@ -0,0 +1,64 @@
+/**
+ * Theme — ANSI color utilities and color palette.
+ *
+ * Raw ANSI helpers (matching pi's Theme approach) and color definitions
+ * used across all rendering functions.
+ */
+// ─── Raw ANSI helpers ───
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return [
+        parseInt(h.substring(0, 2), 16),
+        parseInt(h.substring(2, 4), 16),
+        parseInt(h.substring(4, 6), 16),
+    ];
+}
+export function fg(hex) {
+    const [r, g, b] = hexToRgb(hex);
+    const open = `\x1b[38;2;${r};${g};${b}m`;
+    return (s) => `${open}${s}\x1b[39m`;
+}
+export function bg(hex) {
+    const [r, g, b] = hexToRgb(hex);
+    const open = `\x1b[48;2;${r};${g};${b}m`;
+    return (s) => `${open}${s}\x1b[49m`;
+}
+export const bold = (s) => `\x1b[1m${s}\x1b[22m`;
+export const italic = (s) => `\x1b[3m${s}\x1b[23m`;
+export const dim = (s) => `\x1b[2m${s}\x1b[22m`;
+export const underline = (s) => `\x1b[4m${s}\x1b[24m`;
+export const strikethrough = (s) => `\x1b[9m${s}\x1b[29m`;
+// ─── Theme colors (pi dark.json) ───
+export const theme = {
+    accent: fg('#8abeb7'),
+    success: fg('#b5bd68'),
+    error: fg('#cc6666'),
+    warning: fg('#ffff00'),
+    muted: fg('#808080'),
+    dim: fg('#666666'),
+    thinkingText: (s) => italic(fg('#808080')(s)),
+    toolOutput: fg('#808080'),
+};
+export const toolBg = {
+    success: bg('#283228'),
+    error: bg('#3c2828'),
+};
+export const TAG = dim(fg('#00d7ff')('pish')); // cyan dim
+export function createMarkdownTheme() {
+    return {
+        heading: (s) => bold(fg('#f0c674')(s)),
+        link: fg('#81a2be'),
+        linkUrl: fg('#666666'),
+        code: fg('#8abeb7'),
+        codeBlock: fg('#b5bd68'),
+        codeBlockBorder: fg('#808080'),
+        quote: fg('#808080'),
+        quoteBorder: fg('#808080'),
+        hr: fg('#808080'),
+        listBullet: fg('#8abeb7'),
+        bold,
+        italic,
+        strikethrough,
+        underline,
+    };
+}

package/dist/vterm.js

@@ -0,0 +1,59 @@
+/**
+ * Virtual terminal replay for the prompt segment.
+ *
+ * Uses @xterm/headless to replay raw PTY data and extract the final
+ * displayed text. Handles readline editing, ANSI colors, cursor
+ * movement, etc.
+ *
+ * Reuses a single Terminal instance (reset + write) to avoid
+ * repeated construction overhead.
+ */
+// @xterm/headless 6.0.0 lacks an "exports" field in package.json,
+// so Node ESM resolution only sees "main" (CJS). Use createRequire
+// as a workaround until the next stable release (#5632).
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { Terminal } = require('@xterm/headless');
+// Lazily initialized shared Terminal instance
+let sharedTerm = null;
+function getTerm(cols, rows) {
+    if (sharedTerm) {
+        if (sharedTerm.cols !== cols || sharedTerm.rows !== rows) {
+            sharedTerm.resize(cols, rows);
+        }
+        sharedTerm.reset();
+        return sharedTerm;
+    }
+    sharedTerm = new Terminal({
+        cols,
+        rows,
+        scrollback: 200,
+        allowProposedApi: true,
+        logLevel: 'off',
+    });
+    return sharedTerm;
+}
+/**
+ * Replay raw PTY data and return the final displayed text.
+ * Digests readline editing, ANSI color, cursor operations, alt screen, etc.
+ */
+export function vtermReplay(data, cols = 120, rows = 30) {
+    return new Promise((resolve) => {
+        const term = getTerm(cols, rows);
+        term.write(data, () => {
+            const buf = term.buffer.active;
+            const lines = [];
+            // scrollback (baseY lines scrolled off top) + viewport (up to cursorY)
+            const totalLines = buf.baseY + buf.cursorY + 1;
+            for (let i = 0; i < totalLines; i++) {
+                const line = buf.getLine(i)?.translateToString(true);
+                lines.push(line?.trimEnd() ?? '');
+            }
+            // Trim trailing empty lines
+            while (lines.length > 0 && lines[lines.length - 1] === '') {
+                lines.pop();
+            }
+            resolve(lines.join('\n'));
+        });
+    });
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@aerode/pish",
+  "version": "0.8.0",
+  "description": "A shell-first pi coding agent",
+  "license": "MIT",
+  "author": "dacapoday",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dacapoday/pish.git"
+  },
+  "homepage": "https://github.com/dacapoday/pish",
+  "bugs": {
+    "url": "https://github.com/dacapoday/pish/issues"
+  },
+  "keywords": ["shell", "ai", "coding-agent", "bash", "zsh", "pi", "cli"],
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "module",
+  "bin": {
+    "pish": "dist/main.js"
+  },
+  "scripts": {
+    "postinstall": "sh postinstall.sh",
+    "build": "tsc && tsc -p tsconfig.test.json && chmod +x dist/main.js",
+    "clean": "rm -rf dist",
+    "start": "node dist/main.js",
+    "dev": "tsc --watch",
+    "lint": "biome check src/ test/",
+    "test": "bash test/run_tests.sh",
+    "test:unit": "npx tsx --test test/unit/*.test.ts"
+  },
+  "files": [
+    "dist",
+    "!dist/test",
+    "README.md",
+    "postinstall.sh"
+  ],
+  "dependencies": {
+    "@mariozechner/pi-tui": "^0.64.0",
+    "@xterm/headless": "^6.0.0",
+    "node-pty": "^1.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.10",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/postinstall.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+# node-pty@1.1.0 ships prebuilt binaries without the execute bit set, which
+# causes "posix_spawnp failed" at runtime on macOS/Linux. Fix it here.
+PREBUILDS="$PWD/node_modules/node-pty/prebuilds"
+if [ -d "$PREBUILDS" ]; then
+  find "$PREBUILDS" \( -name "spawn-helper" -o -name "*.node" \) -exec chmod +x {} \; 2>/dev/null || true
+fi