nexrall-code 0.5.107 → 0.5.108

package/dist/terminal/terminalSetup.js

@@ -0,0 +1,395 @@
+// ─── /terminal-setup: make Shift+Enter insert a newline ─────────────────────
+//
+// WHY THIS EXISTS
+//
+// Pressing Shift+Enter in the input box submits the line on most terminals
+// instead of inserting a newline, and no amount of work inside this CLI can
+// change that — the terminal never tells us Shift was held. Measured directly:
+// VS Code sends a bare `\r` for Shift+Enter, byte-identical to a plain Enter,
+// so the two are indistinguishable before the terminal is reconfigured.
+//
+// The fix is therefore split across two layers, and BOTH are required:
+//
+//   • This module reconfigures the terminal to send a DISTINCT sequence for
+//     Shift+Enter — `ESC CR` (`\x1b\r`).
+//   • ui/inkTerminal.tsx's decideEnterKey recognises that sequence (it arrives
+//     as return+meta, not return+shift) and inserts a newline.
+//
+// Getting only one of the two is useless, which is exactly the state this CLI
+// shipped in: the handler had a `key.shift` branch that no terminal could ever
+// trigger, and there was no command to install a keybinding in the first place.
+//
+// Terminals fall into three groups (per Claude Code's own terminal-config
+// documentation, cross-checked against the `claude` binary's behaviour):
+//
+//   • Ghostty, Kitty, iTerm2, WezTerm, Warp, Windows Terminal — already send a
+//     distinct sequence. Nothing to install.
+//   • VS Code, Cursor, Windsurf, VSCodium — need a `sendSequence` keybinding.
+//   • Apple Terminal — has no Shift+Enter binding to install before macOS 27;
+//     the supported route is Option+Enter, which needs "Use Option as Meta
+//     Key" enabled. macOS 27 gained Shift+Return natively.
+//
+// Everywhere, Ctrl+J already inserts a newline with no setup at all — that is
+// what decideEnterKey's lone-`\n` rule buys, and it is why this command is a
+// convenience rather than the only way to get a multi-line prompt.
+import * as os from 'os';
+import * as path from 'path';
+/**
+ * The sequence a terminal must send for Shift+Enter.
+ *
+ * `ESC CR`. Ink parses this as `return` with `meta: true` (NOT `shift`), which
+ * is why decideEnterKey keys off meta — see its own table. Deliberately
+ * identical to what `claude`'s /terminal-setup installs, so a machine set up
+ * for either tool works with both, and so a user who already ran claude's
+ * version needs no second keybinding.
+ */
+export const SHIFT_ENTER_SEQUENCE = '\x1b\r';
+/**
+ * Terminals that send a distinct Shift+Enter sequence out of the box, keyed by
+ * the `TERM_PROGRAM` value each one sets. Values are display names.
+ *
+ * Sourced from Claude Code's terminal-config table. Kept as data rather than a
+ * chain of `if`s so the list is inspectable by the test that pins it.
+ */
+const NATIVE_SHIFT_ENTER = {
+    ghostty: 'Ghostty',
+    'iTerm.app': 'iTerm2',
+    WezTerm: 'WezTerm',
+    WarpTerminal: 'Warp',
+    // Kitty sets TERM=xterm-kitty rather than TERM_PROGRAM; handled below.
+};
+/** Editors that need a keybinding, keyed by their `TERM_PROGRAM` value. */
+const EDITOR_TERM_PROGRAMS = {
+    vscode: 'VS Code',
+    cursor: 'Cursor',
+    windsurf: 'Windsurf',
+    vscodium: 'VSCodium',
+};
+/**
+ * The first macOS major version whose Terminal.app sends a distinct
+ * Shift+Return on its own.
+ *
+ * Taken from the `claude` binary, which gates its Terminal.app setup on
+ * `macOSMajor >= 27` and below that tells the user "Option+Enter will now
+ * enter a newline" instead. Below 27 there is no Shift+Enter binding to
+ * install — Option+Enter is the supported route.
+ */
+export const MACOS_NATIVE_SHIFT_RETURN_MAJOR = 27;
+/**
+ * Decides what /terminal-setup should do, from environment alone. Pure so the
+ * terminal matrix is testable — the whole point of this command is that its
+ * behaviour differs per terminal, and none of that is observable otherwise.
+ *
+ * `env` is `process.env`-shaped; `platform` is `process.platform`;
+ * `macOSMajor` is the major version from `os.release()` (Darwin kernel major
+ * minus 9 — see `detectMacOSMajor`), or null off macOS.
+ */
+export function decideTerminalSetup(input) {
+    const termProgram = input.env.TERM_PROGRAM ?? null;
+    const term = input.env.TERM ?? null;
+    // Kitty advertises itself through TERM, not TERM_PROGRAM.
+    if (term && term.includes('kitty'))
+        return { kind: 'already-native', terminal: 'Kitty' };
+    // Windows Terminal sets WT_SESSION and no TERM_PROGRAM.
+    if (input.env.WT_SESSION)
+        return { kind: 'already-native', terminal: 'Windows Terminal' };
+    if (termProgram) {
+        const native = NATIVE_SHIFT_ENTER[termProgram];
+        if (native)
+            return { kind: 'already-native', terminal: native };
+        const editor = EDITOR_TERM_PROGRAMS[termProgram];
+        if (editor)
+            return { kind: 'editor', editor };
+        if (termProgram === 'Apple_Terminal') {
+            if (input.macOSMajor !== null && input.macOSMajor >= MACOS_NATIVE_SHIFT_RETURN_MAJOR) {
+                return { kind: 'already-native', terminal: 'Apple Terminal' };
+            }
+            return { kind: 'apple-terminal', macOSMajor: input.macOSMajor };
+        }
+    }
+    // An editor's integrated terminal can lose TERM_PROGRAM (it is unset when
+    // the CLI is launched from an extension host rather than a shell, and TERM
+    // falls back to "dumb"). VSCODE_PID / CURSOR_* are still present, so fall
+    // back to them rather than reporting "unsupported" inside VS Code — which is
+    // the single most likely place this command is run.
+    if (input.env.VSCODE_PID || input.env.VSCODE_IPC_HOOK || input.env.VSCODE_CWD) {
+        return { kind: 'editor', editor: editorFromBundleId(input.env.__CFBundleIdentifier) };
+    }
+    return { kind: 'unsupported', terminal: termProgram };
+}
+/**
+ * Distinguishes VS Code from its forks when only VSCODE_* vars are present.
+ * The forks keep VS Code's own env var names, so the macOS bundle id is the
+ * only thing that still differs.
+ */
+function editorFromBundleId(bundleId) {
+    switch (bundleId) {
+        case 'com.todesktop.230313mzl4w4u92': // Cursor's (stable) bundle id
+        case 'com.cursor.Cursor':
+            return 'Cursor';
+        case 'com.exafunction.windsurf':
+            return 'Windsurf';
+        case 'com.vscodium':
+        case 'com.visualstudio.code.oss':
+            return 'VSCodium';
+        default:
+            return 'VS Code';
+    }
+}
+/**
+ * Major macOS version (e.g. 26), derived from the Darwin kernel release.
+ *
+ * Since macOS 11, the Darwin major has run exactly ONE behind the macOS major
+ * (verified on this machine: os.release() "25.2.0" with sw_vers reporting
+ * macOS 26.2, so Darwin 25 = macOS 26). Returns null off macOS or when the
+ * release is unparseable, and callers treat null as "not known to be native",
+ * which is the safe direction:
+ * it offers the Option+Enter setup rather than wrongly claiming Shift+Enter
+ * already works.
+ */
+export function detectMacOSMajor(platform = process.platform, release = os.release()) {
+    if (platform !== 'darwin')
+        return null;
+    const darwinMajor = Number.parseInt(release.split('.')[0] ?? '', 10);
+    if (!Number.isFinite(darwinMajor))
+        return null;
+    return darwinMajor + 1;
+}
+/** Directory name each editor uses under the user's config root. */
+const EDITOR_CONFIG_DIR = {
+    'VS Code': 'Code',
+    Cursor: 'Cursor',
+    Windsurf: 'Windsurf',
+    VSCodium: 'VSCodium',
+};
+/**
+ * Absolute path to an editor's `keybindings.json`.
+ *
+ * Mirrors the layout `claude` uses: `AppData/Roaming/<dir>/User` on Windows,
+ * `Library/Application Support/<dir>/User` on macOS, `.config/<dir>/User`
+ * elsewhere.
+ */
+export function keybindingsPath(editor, platform = process.platform, home = os.homedir()) {
+    const dir = EDITOR_CONFIG_DIR[editor];
+    const userDir = platform === 'win32'
+        ? path.join(home, 'AppData', 'Roaming', dir, 'User')
+        : platform === 'darwin'
+            ? path.join(home, 'Library', 'Application Support', dir, 'User')
+            : path.join(home, '.config', dir, 'User');
+    return path.join(userDir, 'keybindings.json');
+}
+export const SHIFT_ENTER_KEYBINDING = {
+    key: 'shift+enter',
+    command: 'workbench.action.terminal.sendSequence',
+    args: { text: SHIFT_ENTER_SEQUENCE },
+    when: 'terminalFocus',
+};
+/**
+ * Decides how to merge the Shift+Enter binding into a parsed keybindings.json.
+ *
+ * Pure and separate from the file I/O so every branch — conflict, idempotent
+ * re-run, malformed file — is testable without touching a real config
+ * directory. `parsed` is whatever JSON.parse produced (`undefined` when the
+ * file does not exist yet).
+ */
+export function mergeKeybinding(parsed, binding = SHIFT_ENTER_KEYBINDING) {
+    if (parsed === undefined || parsed === null)
+        return { kind: 'insert', next: [binding] };
+    if (!Array.isArray(parsed))
+        return { kind: 'not-an-array' };
+    const existing = parsed.find((entry) => typeof entry === 'object' &&
+        entry !== null &&
+        entry.key === binding.key &&
+        entry.command === binding.command &&
+        entry.when === binding.when);
+    if (existing) {
+        if (existing.args?.text === binding.args?.text)
+            return { kind: 'already-configured' };
+        return { kind: 'conflict', existingText: existing.args?.text };
+    }
+    return { kind: 'insert', next: [...parsed, binding] };
+}
+/**
+ * Parses a keybindings.json body.
+ *
+ * VS Code writes this file with `//` comments in its default template, and
+ * `JSON.parse` rejects those — so a first-time user's file (which is nothing
+ * but comments and an empty array) would look corrupt and abort the install.
+ * Comments are stripped before parsing for that reason. Returns `undefined`
+ * for an empty/whitespace body, and throws only when the content is genuinely
+ * not JSON.
+ */
+export function parseKeybindingsFile(body) {
+    const withoutComments = stripJsonComments(body).trim();
+    if (withoutComments === '')
+        return undefined;
+    return JSON.parse(withoutComments);
+}
+/**
+ * Removes `//` and block comments, preserving anything inside string literals
+ * (a `//` in a "when" clause or a Windows path must survive) and escape
+ * sequences within them.
+ */
+function stripJsonComments(input) {
+    let out = '';
+    let inString = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        const next = input[i + 1];
+        if (inLineComment) {
+            if (ch === '\n') {
+                inLineComment = false;
+                out += ch;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            out += ch;
+            // A backslash escapes the next character, so a `\"` does not end the
+            // string — copy both and skip ahead.
+            if (ch === '\\' && next !== undefined) {
+                out += next;
+                i++;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/**
+ * Installs the Shift+Enter keybinding into an editor's keybindings.json.
+ *
+ * The existing file is backed up before any write, because this edits a file
+ * the user owns and may have spent real time on — losing a hand-built
+ * keybindings.json to a bug in this command would be far worse than the
+ * problem it fixes. A backup that cannot be written aborts the install rather
+ * than proceeding unprotected.
+ */
+export async function installEditorKeybinding(editor, deps) {
+    const filePath = keybindingsPath(editor, deps.platform ?? process.platform, deps.home ?? os.homedir());
+    let body;
+    try {
+        body = await deps.readFile(filePath);
+    }
+    catch (err) {
+        // ENOENT is the normal first-run case: no keybindings.json yet. Anything
+        // else (EACCES on a locked-down config dir, EISDIR…) is a real failure and
+        // must not be reported as a successful install.
+        if (err.code !== 'ENOENT') {
+            return { kind: 'failed', filePath, reason: describeErr(err) };
+        }
+    }
+    let parsed;
+    try {
+        parsed = body === undefined ? undefined : parseKeybindingsFile(body);
+    }
+    catch (err) {
+        return {
+            kind: 'failed',
+            filePath,
+            reason: `it isn't valid JSON (${describeErr(err)}) — fix or move it, then retry`,
+        };
+    }
+    const merge = mergeKeybinding(parsed);
+    if (merge.kind === 'already-configured')
+        return { kind: 'already-configured', filePath };
+    if (merge.kind === 'conflict')
+        return { kind: 'conflict', filePath, existingText: merge.existingText };
+    if (merge.kind === 'not-an-array') {
+        return { kind: 'failed', filePath, reason: "it isn't a JSON array — fix or move it, then retry" };
+    }
+    // Back up before writing, but only when there is something to lose.
+    if (body !== undefined) {
+        try {
+            await deps.copyFile(filePath, `${filePath}.${deps.randomSuffix()}.bak`);
+        }
+        catch (err) {
+            return { kind: 'failed', filePath, reason: `couldn't back it up first (${describeErr(err)})` };
+        }
+    }
+    try {
+        await deps.mkdir(path.dirname(filePath));
+        await deps.writeFile(filePath, `${JSON.stringify(merge.next, null, 2)}\n`);
+    }
+    catch (err) {
+        return { kind: 'failed', filePath, reason: describeErr(err) };
+    }
+    return { kind: 'installed', filePath };
+}
+function describeErr(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Enables "Use Option as Meta Key" for Apple Terminal's active profiles, so
+ * Option+Enter sends `ESC CR` and thus inserts a newline.
+ *
+ * This is the Apple Terminal story below macOS 27: there is no Shift+Enter
+ * binding to install (Terminal.app has no keybinding file we can extend the
+ * way an editor does), so Option+Enter is the supported route — which is
+ * exactly what `claude` falls back to on the same versions.
+ *
+ * Both the Default and Startup profiles are updated when they differ, because
+ * changing only one leaves new windows behaving differently from the current
+ * one — a confusing half-fix. `Add` is tried before `Set` since the key is
+ * absent on a profile that has never had it (verified on this machine: it did
+ * not exist on the "Basic" profile).
+ */
+export async function enableAppleTerminalOptionAsMeta(deps) {
+    const profiles = [];
+    for (const which of ['Default Window Settings', 'Startup Window Settings']) {
+        const res = await deps.run('defaults', ['read', 'com.apple.Terminal', which]);
+        const name = res.stdout.trim();
+        if (res.code === 0 && name && !profiles.includes(name))
+            profiles.push(name);
+    }
+    if (profiles.length === 0) {
+        return { ok: false, profiles: [], reason: "couldn't read Terminal.app's active profile" };
+    }
+    let changed = false;
+    for (const profile of profiles) {
+        const key = `:'Window Settings':'${profile}':useOptionAsMetaKey`;
+        const add = await deps.run('/usr/libexec/PlistBuddy', ['-c', `Add ${key} bool true`, deps.plistPath]);
+        if (add.code === 0) {
+            changed = true;
+            continue;
+        }
+        // Already present (Add fails on an existing key) — set it instead.
+        const set = await deps.run('/usr/libexec/PlistBuddy', ['-c', `Set ${key} true`, deps.plistPath]);
+        if (set.code === 0)
+            changed = true;
+    }
+    if (!changed)
+        return { ok: false, profiles, reason: 'PlistBuddy rejected every profile' };
+    // Terminal.app reads its prefs through cfprefsd, which caches them; without
+    // this the change is invisible until the daemon happens to reload.
+    await deps.run('killall', ['cfprefsd']);
+    return { ok: true, profiles };
+}

package/dist/trust.js

@@ -0,0 +1,137 @@
+import fs from 'fs';
+import path from 'path';
+// ─── Workspace Trust ───────────────────────────────────────────────────────
+//
+// Opening a folder in `nex` is not a passive act. Before the user types
+// anything, the session already reads and acts on files found in that folder:
+//
+//   • `.nexrall/mcp.json` declares MCP servers, and connecting to a stdio
+//     server runs `spawn(server.command, server.args)` — arbitrary command
+//     execution, straight from a file in the repo.
+//   • `nexrall.md` is injected into the system prompt as trusted project
+//     instructions, so its contents steer the agent for the whole session.
+//   • `.nexrall/{skills,commands}` define playbooks the agent will follow, and
+//     `.nexrall/permissions.json` can pre-approve tool calls that would
+//     otherwise prompt.
+//   • `.agents/skills/` is the same kind of playbook, discovered from the
+//     agentskills.io cross-client convention (core's agent/skills.ts) rather
+//     than a Nexrall-specific path — worth its own line since it may have
+//     been authored for a different client entirely.
+//
+// So `git clone` of a hostile repo followed by `nex` is enough to execute
+// attacker-chosen commands. The confirmation prompt is what turns that into a
+// deliberate user decision.
+//
+// ── Why trust is NOT remembered between sessions ──────────────────────────
+//
+// An earlier version of this file persisted trusted folders to
+// ~/.nexrall/trusted-folders.json and skipped the prompt on later runs. That
+// is weaker than it looks, because trust was granted to a PATH while the risk
+// lives in the folder's CONTENTS, and contents change:
+//
+//   1. You trust ~/work/api today. It has no .nexrall/mcp.json.
+//   2. Tomorrow `git pull` (or a dependency update, or a teammate's commit)
+//      adds .nexrall/mcp.json.
+//   3. You run `nex` — and because the path was trusted once, the prompt never
+//      appears and the new server is spawned silently.
+//
+// Persisting trust therefore hands future, unreviewed content the approval the
+// user gave to the content they saw once. Asking every session keeps the
+// decision attached to what is in the folder RIGHT NOW, which is the thing
+// that can actually hurt you. The cost is one keystroke per session; the
+// benefit is that a newly-introduced mcp.json can never run un-announced.
+// (Claude Code behaves the same way — it re-asks on every start rather than
+// remembering.)
+//
+// This module is consequently stateless: there is no trust store, nothing
+// written to disk, and nothing a repository could plant to mark itself
+// trusted.
+/**
+ * Escape hatch for non-interactive runs, which have no way to show a prompt.
+ *
+ * This is deliberately an ENVIRONMENT VARIABLE and not a file: it must be set
+ * by whoever invokes the process (a CI job, a wrapper script), and cannot be
+ * committed into a repository the way a config file could. A hostile repo
+ * therefore cannot grant itself trust.
+ */
+export const TRUST_ENV_VAR = 'NEXRALL_TRUST_WORKSPACE';
+/** True when the invoker explicitly pre-authorised this run via the environment. */
+export function trustGrantedByEnv() {
+    const v = process.env[TRUST_ENV_VAR];
+    return v === '1' || v === 'true';
+}
+/**
+ * Which trust-sensitive files actually exist in `dir`, so the prompt can tell
+ * the user what THIS folder will do rather than describing risks in the
+ * abstract. Ordered most- to least-dangerous.
+ */
+/** Does the project settings file bind plugin aliases to remote repos? */
+function declaresPluginSources(dir) {
+    try {
+        const raw = fs.readFileSync(path.join(dir, '.nexrall', 'settings.json'), 'utf-8');
+        const obj = JSON.parse(raw);
+        const s = obj.pluginSources;
+        return Boolean(s && typeof s === 'object' && !Array.isArray(s) && Object.keys(s).length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+export function detectTrustSignals(dir) {
+    const signals = [];
+    const exists = (...p) => {
+        try {
+            return fs.existsSync(path.join(dir, ...p));
+        }
+        catch {
+            return false;
+        }
+    };
+    // Code-executing first — these can run local commands before the user types
+    // anything, so they are what the decision really hinges on.
+    if (exists('.nexrall', 'mcp.json')) {
+        signals.push('.nexrall/mcp.json — can start MCP servers (runs local commands)');
+    }
+    if (exists('.nexrall', 'plugins')) {
+        // Plugins are scanned from the workspace and may contribute their own MCP
+        // servers (see core/src/plugins/index.ts → pluginMcpServers), so this is in
+        // the same risk class as mcp.json rather than a cosmetic add-on.
+        signals.push('.nexrall/plugins/ — project plugins (may add MCP servers)');
+    }
+    // Then things that widen what the agent may do without asking.
+    if (exists('.nexrall', 'permissions.json')) {
+        signals.push('.nexrall/permissions.json — pre-approved tool permissions');
+    }
+    if (exists('.nexrall', 'settings.json')) {
+        // Called out separately when the file declares plugin sources: those bind a
+        // short alias to a remote repo, so `nex plugin install <alias>` would fetch
+        // whatever the REPOSITORY chose. Installing still needs a human and its own
+        // confirmation — nothing is fetched from a declaration alone — but the user
+        // should know the repo is trying to name what they install.
+        signals.push(declaresPluginSources(dir)
+            ? '.nexrall/settings.json — project settings, and declares plugin sources (aliases for remote plugin repos)'
+            : '.nexrall/settings.json — project settings and permission rules');
+    }
+    // Then things that steer the agent's behaviour.
+    if (exists('nexrall.md')) {
+        signals.push('nexrall.md — project instructions added to the agent’s prompt');
+    }
+    if (exists('.nexrall', 'skills')) {
+        signals.push('.nexrall/skills/ — custom agent playbooks');
+    }
+    if (exists('.nexrall', 'commands')) {
+        signals.push('.nexrall/commands/ — custom slash commands');
+    }
+    if (exists('.nexrall', 'agents')) {
+        signals.push('.nexrall/agents/ — custom sub-agent definitions');
+    }
+    if (exists('.agents', 'skills')) {
+        // Same risk class as .nexrall/skills/ (instructions the agent follows,
+        // not code it executes) — called out separately because this path is the
+        // agentskills.io cross-client convention, so a skill here may have been
+        // authored for/by a DIFFERENT tool than the one asking to trust this
+        // folder right now.
+        signals.push('.agents/skills/ — cross-client agent playbooks (agentskills.io convention)');
+    }
+    return signals;
+}

package/dist/ui/diff.js

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import { structuredPatch } from 'diff';
+// ─── Show Diff ────────────────────────────────────────────────────────────────
+/**
+ * Display a unified diff between oldContent and newContent for the given path.
+ * If oldContent is null the file is treated as newly created.
+ */
+export function showDiff(filePath, oldContent, newContent) {
+    const isNew = oldContent === null;
+    const from = isNew ? '/dev/null' : `a/${filePath}`;
+    const to = `b/${filePath}`;
+    console.log();
+    console.log(chalk.bold(`--- ${from}`));
+    console.log(chalk.bold(`+++ ${to}`));
+    if (isNew) {
+        // Show the entire new file as additions
+        const lines = newContent.split('\n');
+        // Remove trailing empty line artifact from split
+        if (lines[lines.length - 1] === '')
+            lines.pop();
+        console.log(chalk.cyan(`@@ -0,0 +1,${lines.length} @@`));
+        for (const line of lines) {
+            console.log(chalk.green(`+${line}`));
+        }
+        console.log();
+        return;
+    }
+    // Compute unified diff using the diff package
+    const patch = structuredPatch(from, to, oldContent, newContent, '', '', { context: 3 });
+    if (patch.hunks.length === 0) {
+        console.log(chalk.dim('  (no changes)'));
+        console.log();
+        return;
+    }
+    for (const hunk of patch.hunks) {
+        const hunkHeader = `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
+        console.log(chalk.cyan(hunkHeader));
+        for (const line of hunk.lines) {
+            if (line.startsWith('+')) {
+                console.log(chalk.green(line));
+            }
+            else if (line.startsWith('-')) {
+                console.log(chalk.red(line));
+            }
+            else {
+                console.log(chalk.gray(line));
+            }
+        }
+    }
+    console.log();
+}