blyuecode 0.1.8 → 0.1.10

package/dist/core/agent.js

@@ -1,28 +1,54 @@
 import { Provider } from './provider.js';
-import { toolDefs, executeTool } from './tools.js';
+import { getToolDefs, executeTool } from './tools.js';
+import { loadSession, saveSession, clearSession } from './session.js';
+const SYSTEM_PROMPT = 'You are BLYUE, a coding assistant running in a terminal. ' +
+    'Use tools to read, write, and run commands. ' +
+    'If n8n tools are available, you can also manage n8n workflows. ' +
+    'Always explain what you are doing. Be concise.';
 export class Agent {
     provider = null;
+    messages;
+    constructor(resume = true) {
+        const sys = { role: 'system', content: SYSTEM_PROMPT };
+        const history = resume ? loadSession() : null;
+        if (history && history.length > 0) {
+            this.messages = [sys, ...history];
+        }
+        else {
+            this.messages = [sys];
+        }
+    }
     getProvider() {
         if (!this.provider)
             this.provider = new Provider();
         return this.provider;
     }
-    messages = [
-        {
-            role: 'system',
-            content: 'You are BLYUE, a coding assistant running in a terminal. ' +
-                'Use tools to read, write, run commands, and manage n8n workflows. ' +
-                'Always explain what you are doing. Be concise.',
-        },
-    ];
+    persist() {
+        try {
+            saveSession(this.messages.slice(1)); // skip system prompt
+        }
+        catch { }
+    }
+    historySize() {
+        return this.messages.length - 1;
+    }
+    clear() {
+        this.messages = [{ role: 'system', content: SYSTEM_PROMPT }];
+        clearSession();
+    }
     async *run(userInput) {
         this.messages.push({ role: 'user', content: userInput });
+        this.persist();
         while (true) {
-            const res = await this.getProvider().chat(this.messages, toolDefs);
-            if (res.content)
+            const tools = getToolDefs();
+            const res = await this.getProvider().chat(this.messages, tools);
+            if (res.content) {
                 yield res.content;
-            if (res.toolCalls.length === 0)
+            }
+            if (res.toolCalls.length === 0) {
+                this.persist();
                 break;
+            }
             this.messages.push({
                 role: 'assistant',
                 content: res.content,
@@ -48,6 +74,7 @@ export class Agent {
                 const preview = result.length > 500 ? result.slice(0, 500) + '...' : result;
                 yield '[Result]: ' + preview + '\n';
             }
+            this.persist();
         }
     }
 }

package/dist/core/config.js

@@ -3,9 +3,7 @@ import path from 'path';
 import os from 'os';
 const GLOBAL_DIR = path.join(os.homedir(), '.blyue');
 const GLOBAL_ENV = path.join(GLOBAL_DIR, '.env');
-// Anything matching this = not a real key
 const PLACEHOLDER = /your[-_]?key|placeholder|^sk-your|^xxx|^sk-xxx|here$/i;
-/** Only look at ~/.blyue/.env (global, works from any cwd) */
 export function loadConfig() {
     if (!fs.existsSync(GLOBAL_ENV))
         return null;
@@ -20,7 +18,7 @@ function parseEnv(file) {
     const text = fs.readFileSync(file, 'utf8');
     const map = {};
     for (const line of text.split('\n')) {
-        const m = line.match(/^\s*([A-Z_]+)\s*=\s*(.*)\s*$/);
+        const m = line.match(/^\s*([A-Z_0-9]+)\s*=\s*(.*)\s*$/);
         if (m)
             map[m[1]] = m[2].trim();
     }
@@ -28,6 +26,8 @@ function parseEnv(file) {
         apiKey: map.OPENAI_API_KEY || '',
         baseUrl: map.OPENAI_BASE_URL || undefined,
         model: map.MODEL || 'gpt-4o-mini',
+        n8nUrl: map.N8N_URL || undefined,
+        n8nApiKey: map.N8N_API_KEY || undefined,
     };
 }
 export function saveConfig(cfg) {
@@ -40,6 +40,10 @@ export function saveConfig(cfg) {
     if (cfg.baseUrl)
         lines.push(`OPENAI_BASE_URL=${cfg.baseUrl}`);
     lines.push(`MODEL=${cfg.model}`);
+    if (cfg.n8nUrl)
+        lines.push(`N8N_URL=${cfg.n8nUrl}`);
+    if (cfg.n8nApiKey)
+        lines.push(`N8N_API_KEY=${cfg.n8nApiKey}`);
     lines.push('');
     fs.writeFileSync(GLOBAL_ENV, lines.join('\n'), { mode: 0o600 });
     return GLOBAL_ENV;
@@ -48,5 +52,31 @@ export function applyConfig(cfg) {
     process.env.OPENAI_API_KEY = cfg.apiKey;
     if (cfg.baseUrl)
         process.env.OPENAI_BASE_URL = cfg.baseUrl;
+    else
+        delete process.env.OPENAI_BASE_URL;
     process.env.MODEL = cfg.model;
+    if (cfg.n8nUrl)
+        process.env.N8N_URL = cfg.n8nUrl;
+    else
+        delete process.env.N8N_URL;
+    if (cfg.n8nApiKey)
+        process.env.N8N_API_KEY = cfg.n8nApiKey;
+    else
+        delete process.env.N8N_API_KEY;
+}
+export function getConfig() {
+    const cfg = loadConfig();
+    if (cfg)
+        return cfg;
+    return {
+        apiKey: process.env.OPENAI_API_KEY || '',
+        baseUrl: process.env.OPENAI_BASE_URL,
+        model: process.env.MODEL || 'gpt-4o-mini',
+        n8nUrl: process.env.N8N_URL,
+        n8nApiKey: process.env.N8N_API_KEY,
+    };
+}
+export function hasN8n() {
+    const cfg = getConfig();
+    return !!(cfg.n8nUrl && cfg.n8nApiKey);
 }

package/dist/core/diff.js

@@ -0,0 +1,63 @@
+// Simple LCS-based line diff. Good enough for previews.
+export function lineDiff(oldText, newText) {
+    const a = oldText.length ? oldText.split('\n') : [];
+    const b = newText.length ? newText.split('\n') : [];
+    const m = a.length;
+    const n = b.length;
+    // LCS table
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            if (a[i] === b[j])
+                dp[i][j] = dp[i + 1][j + 1] + 1;
+            else
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            out.push({ type: 'same', text: a[i] });
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            out.push({ type: 'remove', text: a[i] });
+            i++;
+        }
+        else {
+            out.push({ type: 'add', text: b[j] });
+            j++;
+        }
+    }
+    while (i < m)
+        out.push({ type: 'remove', text: a[i++] });
+    while (j < n)
+        out.push({ type: 'add', text: b[j++] });
+    return out;
+}
+// Compact display: only show changed regions with context
+export function compactDiff(diff, context = 2) {
+    const keep = new Set();
+    diff.forEach((d, idx) => {
+        if (d.type !== 'same') {
+            for (let k = Math.max(0, idx - context); k <= Math.min(diff.length - 1, idx + context); k++) {
+                keep.add(k);
+            }
+        }
+    });
+    const out = [];
+    let lastKept = -1;
+    for (let i = 0; i < diff.length; i++) {
+        if (keep.has(i)) {
+            if (lastKept !== -1 && i > lastKept + 1) {
+                out.push({ type: 'same', text: '…' });
+            }
+            out.push(diff[i]);
+            lastKept = i;
+        }
+    }
+    return out;
+}

package/dist/core/permission.js

@@ -0,0 +1,44 @@
+class PermissionBroker {
+    pending = null;
+    // Session-scoped "always allow" set (cleared on restart)
+    alwaysAllow = new Set();
+    listeners = new Set();
+    nextId = 0;
+    subscribe(fn) {
+        this.listeners.add(fn);
+        // Immediately notify with current state
+        fn(this.pending?.req ?? null);
+        return () => this.listeners.delete(fn);
+    }
+    notify(req) {
+        for (const fn of this.listeners)
+            fn(req);
+    }
+    isAlwaysAllowed(tool) {
+        return this.alwaysAllow.has(tool);
+    }
+    async ask(req) {
+        if (this.alwaysAllow.has(req.tool))
+            return 'yes';
+        const id = `p${++this.nextId}`;
+        const full = { ...req, id };
+        return new Promise((resolve) => {
+            this.pending = { req: full, resolve };
+            this.notify(full);
+        });
+    }
+    answer(a) {
+        if (!this.pending)
+            return;
+        const { req, resolve } = this.pending;
+        if (a === 'always')
+            this.alwaysAllow.add(req.tool);
+        this.pending = null;
+        this.notify(null);
+        resolve(a);
+    }
+    resetSession() {
+        this.alwaysAllow.clear();
+    }
+}
+export const permissions = new PermissionBroker();

package/dist/core/session.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+const SESSIONS_DIR = path.join(os.homedir(), '.blyue', 'sessions');
+export function sessionFile(cwd = process.cwd()) {
+    if (!fs.existsSync(SESSIONS_DIR))
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    const hash = crypto.createHash('sha1').update(cwd).digest('hex').slice(0, 12);
+    return path.join(SESSIONS_DIR, `${hash}.json`);
+}
+export function loadSession(cwd = process.cwd()) {
+    const file = sessionFile(cwd);
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return data.messages || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveSession(messages, cwd = process.cwd()) {
+    const file = sessionFile(cwd);
+    const data = {
+        project: cwd,
+        updatedAt: Date.now(),
+        messages,
+    };
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+export function clearSession(cwd = process.cwd()) {
+    const file = sessionFile(cwd);
+    if (fs.existsSync(file))
+        fs.unlinkSync(file);
+}
+export function listSessions() {
+    if (!fs.existsSync(SESSIONS_DIR))
+        return [];
+    const out = [];
+    for (const f of fs.readdirSync(SESSIONS_DIR)) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), 'utf8'));
+            out.push({
+                file: f,
+                project: data.project,
+                updatedAt: data.updatedAt,
+                count: data.messages.length,
+            });
+        }
+        catch { }
+    }
+    return out.sort((a, b) => b.updatedAt - a.updatedAt);
+}

package/dist/core/tools.js

@@ -1,13 +1,13 @@
 import fs from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { hasN8n } from './config.js';
+import { permissions } from './permission.js';
+import { lineDiff, compactDiff } from './diff.js';
 import { n8nListWorkflows, n8nTriggerWorkflow, n8nListExecutions, n8nGetWorkflow, n8nActivateWorkflow, n8nDeactivateWorkflow, } from './n8n.js';
 const execAsync = promisify(exec);
-// ─────────────────────────────────────────────
-//  Tool definitions
-// ─────────────────────────────────────────────
-export const toolDefs = [
-    // ───── File ops ─────
+const BASE_TOOLS = [
     {
         type: 'function',
         function: {
@@ -58,111 +58,102 @@ export const toolDefs = [
             },
         },
     },
-    // ───── n8n ─────
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_list_workflows',
-            description: 'List all n8n workflows. Returns id, name, active status, updatedAt.',
-            parameters: { type: 'object', properties: {} },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_get_workflow',
-            description: 'Get details of a specific n8n workflow by ID',
-            parameters: {
-                type: 'object',
-                properties: { id: { type: 'string' } },
-                required: ['id'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_trigger_workflow',
-            description: 'Trigger an n8n workflow via its webhook URL',
-            parameters: {
-                type: 'object',
-                properties: {
-                    workflowId: { type: 'string' },
-                    data: {
-                        type: 'object',
-                        description: 'JSON payload to send to the webhook',
-                    },
-                },
-                required: ['workflowId'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_list_executions',
-            description: 'List recent n8n executions (runs)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    workflowId: { type: 'string', description: 'Filter by workflow ID' },
-                    limit: { type: 'number', description: 'Max results (default 10)' },
-                },
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_activate_workflow',
-            description: 'Activate an n8n workflow so it runs on its trigger',
-            parameters: {
-                type: 'object',
-                properties: { id: { type: 'string' } },
-                required: ['id'],
-            },
-        },
-    },
-    {
-        type: 'function',
-        function: {
-            name: 'n8n_deactivate_workflow',
-            description: 'Deactivate an n8n workflow',
-            parameters: {
-                type: 'object',
-                properties: { id: { type: 'string' } },
-                required: ['id'],
-            },
-        },
-    },
 ];
-// ─────────────────────────────────────────────
-//  Tool execution
-// ─────────────────────────────────────────────
+const N8N_TOOLS = [
+    { type: 'function', function: { name: 'n8n_list_workflows', description: 'List n8n workflows', parameters: { type: 'object', properties: {} } } },
+    { type: 'function', function: { name: 'n8n_get_workflow', description: 'Get n8n workflow by ID', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
+    { type: 'function', function: { name: 'n8n_trigger_workflow', description: 'Trigger n8n workflow', parameters: { type: 'object', properties: { workflowId: { type: 'string' }, data: { type: 'object' } }, required: ['workflowId'] } } },
+    { type: 'function', function: { name: 'n8n_list_executions', description: 'List n8n executions', parameters: { type: 'object', properties: { workflowId: { type: 'string' }, limit: { type: 'number' } } } } },
+    { type: 'function', function: { name: 'n8n_activate_workflow', description: 'Activate n8n workflow', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
+    { type: 'function', function: { name: 'n8n_deactivate_workflow', description: 'Deactivate n8n workflow', parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } } },
+];
+export function getToolDefs() {
+    return hasN8n() ? [...BASE_TOOLS, ...N8N_TOOLS] : [...BASE_TOOLS];
+}
+export const toolDefs = BASE_TOOLS;
+// Dangerous command patterns
+const DANGER_PATTERNS = [
+    { re: /\brm\s+(-[a-z]*[rf][a-z]*\s+)?/, level: 'high' },
+    { re: /\bsudo\b/, level: 'high' },
+    { re: /\bmkfs\b|\bdd\s+if=/, level: 'high' },
+    { re: />\s*\/dev\//, level: 'high' },
+    { re: /:\(\)\s*\{/, level: 'high' }, // fork bomb
+    { re: /\bchmod\s+(-R\s+)?777\b/, level: 'medium' },
+    { re: /\bgit\s+push\b/, level: 'medium' },
+    { re: /\bnpm\s+(publish|unpublish)\b/, level: 'medium' },
+    { re: /\bcurl\b.*\|\s*(sh|bash)\b/, level: 'high' },
+];
+function classify(cmd) {
+    for (const { re, level } of DANGER_PATTERNS) {
+        if (re.test(cmd))
+            return level;
+    }
+    return 'low';
+}
 export async function executeTool(name, args) {
     try {
         switch (name) {
-            // ───── File ops ─────
             case 'read_file':
                 return await fs.readFile(args.path, 'utf8');
-            case 'write_file':
-                await fs.writeFile(args.path, args.content, 'utf8');
-                return 'Wrote ' + args.path;
+            case 'write_file': {
+                const path = args.path;
+                const content = args.content;
+                const existed = existsSync(path);
+                let oldText = '';
+                if (existed) {
+                    try {
+                        oldText = readFileSync(path, 'utf8');
+                    }
+                    catch { }
+                }
+                if (!permissions.isAlwaysAllowed('write_file')) {
+                    const lines = content.split('\n');
+                    const body = [
+                        existed ? `Overwrite ${path}` : `Create ${path}`,
+                        `${lines.length} lines · ${content.length} bytes`,
+                    ];
+                    let diffPreview;
+                    if (existed && oldText !== content) {
+                        const d = compactDiff(lineDiff(oldText, content), 2);
+                        diffPreview = d.slice(0, 60);
+                    }
+                    const answer = await permissions.ask({
+                        tool: 'write_file',
+                        title: existed ? 'Write file' : 'Create file',
+                        body,
+                        diff: diffPreview,
+                        danger: existed ? 'medium' : 'low',
+                    });
+                    if (answer === 'no')
+                        return `Denied by user: write_file ${path}`;
+                }
+                await fs.writeFile(path, content, 'utf8');
+                return 'Wrote ' + path;
+            }
             case 'list_files': {
                 const dir = args.path || '.';
                 const entries = await fs.readdir(dir, { withFileTypes: true });
-                return entries
-                    .map((e) => (e.isDirectory() ? e.name + '/' : e.name))
-                    .join('\n');
+                return entries.map((e) => (e.isDirectory() ? e.name + '/' : e.name)).join('\n');
             }
             case 'run_command': {
-                const { stdout, stderr } = await execAsync(args.command, {
+                const cmd = args.command;
+                if (!permissions.isAlwaysAllowed('run_command')) {
+                    const danger = classify(cmd);
+                    const answer = await permissions.ask({
+                        tool: 'run_command',
+                        title: 'Run command',
+                        body: ['$ ' + cmd, `cwd: ${process.cwd()}`, `risk: ${danger}`],
+                        danger,
+                    });
+                    if (answer === 'no')
+                        return `Denied by user: run_command`;
+                }
+                const { stdout, stderr } = await execAsync(cmd, {
                     cwd: process.cwd(),
                     maxBuffer: 10 * 1024 * 1024,
                 });
                 return 'stdout:\n' + stdout + '\nstderr:\n' + stderr;
             }
-            // ───── n8n ─────
             case 'n8n_list_workflows':
                 return JSON.stringify(await n8nListWorkflows(), null, 2);
             case 'n8n_get_workflow':

package/dist/index.js

@@ -6,20 +6,22 @@ import { Setup } from './ui/Setup.js';
 import { Chat } from './ui/Chat.js';
 import { Banner } from './ui/Banner.js';
 import { loadConfig, applyConfig } from './core/config.js';
+import { loadSession } from './core/session.js';
 const App = () => {
     const [ready, setReady] = useState(false);
+    const [resumedCount, setResumedCount] = useState(0);
     useEffect(() => {
         const existing = loadConfig();
         if (existing) {
             applyConfig(existing);
+            const hist = loadSession();
+            setResumedCount(hist ? hist.length : 0);
             setReady(true);
         }
     }, []);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Static, { items: ['banner'], children: () => _jsx(Banner, {}) }), ready ? _jsx(Chat, {}) : _jsx(Setup, { onDone: () => setReady(true) })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Static, { items: ['banner'], children: () => _jsx(Banner, {}) }), ready ? (_jsx(Chat, { resumedCount: resumedCount })) : (_jsx(Setup, { onDone: () => setReady(true) }))] }));
 };
 render(_jsx(App, {}), {
-    // Prevent console.log interference from npm/openai warnings
     patchConsole: false,
-    // Only redraw when Ink state actually changes
     exitOnCtrlC: true,
 });

package/dist/ui/Chat.js

@@ -1,19 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { Box, Text, useInput, useStdout, Static } from 'ink';
 import { Agent } from '../core/agent.js';
+import { permissions } from '../core/permission.js';
 import { InputBar } from './InputBar.js';
 import { ModelPicker } from './ModelPicker.js';
+import { Settings } from './Settings.js';
+import { PermissionPrompt } from './PermissionPrompt.js';
 import { theme } from './theme.js';
 let nextId = 0;
-const mkItem = (kind, text) => ({
-    kind,
-    text,
-    id: nextId++,
-});
-// ─────────────────────────────────────────────
-//  One history line — rendered ONCE via <Static>
-// ─────────────────────────────────────────────
+const mkItem = (kind, text) => ({ kind, text, id: nextId++ });
 const HistoryLine = ({ item }) => {
     if (item.kind === 'user') {
         return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: '❯ ' }), _jsx(Text, { color: theme.text, bold: true, children: item.text })] }));
@@ -26,18 +22,33 @@ const HistoryLine = ({ item }) => {
     }
     return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.text, children: item.text }) }));
 };
-export const Chat = () => {
+export const Chat = ({ resumedCount = 0 }) => {
     const { stdout } = useStdout();
     const width = stdout?.columns ?? 80;
-    const [history, setHistory] = useState([]);
+    const [history, setHistory] = useState(() => {
+        if (resumedCount > 0) {
+            return [mkItem('tool', `(resumed session · ${resumedCount} prior messages)`)];
+        }
+        return [];
+    });
     const [input, setInput] = useState('');
     const [loading, setLoading] = useState(false);
-    const [modelPickerOpen, setModelPickerOpen] = useState(false);
+    const [overlay, setOverlay] = useState('none');
+    const [permReq, setPermReq] = useState(null);
     const [currentModel, setCurrentModel] = useState(process.env.MODEL || '');
     const [agent, setAgent] = useState(() => new Agent());
+    // Subscribe to permission requests
+    useEffect(() => {
+        const unsub = permissions.subscribe((req) => setPermReq(req));
+        return unsub;
+    }, []);
     useInput((inputChar, key) => {
+        if (permReq)
+            return; // permission prompt handles its own input
         if (key.ctrl && inputChar === 'p')
-            setModelPickerOpen(true);
+            setOverlay('model');
+        if (key.ctrl && inputChar === 's')
+            setOverlay('settings');
     });
     const handleSubmit = async (text) => {
         if (!text.trim() || loading)
@@ -45,7 +56,31 @@ export const Chat = () => {
         const trimmed = text.trim();
         if (trimmed === '/model' || trimmed === '/models') {
             setInput('');
-            setModelPickerOpen(true);
+            setOverlay('model');
+            return;
+        }
+        if (trimmed === '/settings' || trimmed === '/config') {
+            setInput('');
+            setOverlay('settings');
+            return;
+        }
+        if (trimmed === '/clear') {
+            setInput('');
+            agent.clear();
+            permissions.resetSession();
+            setHistory([mkItem('tool', '(conversation cleared)')]);
+            return;
+        }
+        if (trimmed === '/help') {
+            setInput('');
+            setHistory((h) => [
+                ...h,
+                mkItem('tool', 'Commands:'),
+                mkItem('tool', '  /model     switch model          (Ctrl+P)'),
+                mkItem('tool', '  /settings  open settings         (Ctrl+S)'),
+                mkItem('tool', '  /clear     clear session and permissions'),
+                mkItem('tool', '  /help      show this list'),
+            ]);
             return;
         }
         setInput('');
@@ -65,16 +100,26 @@ export const Chat = () => {
     const handleModelSelect = (id) => {
         process.env.MODEL = id;
         setCurrentModel(id);
-        setModelPickerOpen(false);
+        setOverlay('none');
         setAgent(new Agent());
         setHistory((h) => [...h, mkItem('tool', `model → ${id}`)]);
     };
-    if (modelPickerOpen) {
-        return (_jsx(Box, { flexDirection: "column", children: _jsx(ModelPicker, { current: currentModel, onSelect: handleModelSelect, onCancel: () => setModelPickerOpen(false) }) }));
+    // Permission prompt takes priority over everything
+    if (permReq) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: history, children: (item) => _jsx(HistoryLine, { item: item }, item.id) }), _jsx(Box, { marginTop: 1, children: _jsx(PermissionPrompt, { req: permReq }) })] }));
+    }
+    if (overlay === 'model') {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(ModelPicker, { current: currentModel, onSelect: handleModelSelect, onCancel: () => setOverlay('none') }) }));
+    }
+    if (overlay === 'settings') {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Settings, { onClose: () => setOverlay('none'), onModelChange: (m) => {
+                    setCurrentModel(m);
+                    setAgent(new Agent());
+                } }) }));
     }
     const maxModelLen = Math.max(10, width - 14);
     const shortModel = currentModel.length > maxModelLen
         ? '…' + currentModel.slice(-(maxModelLen - 1))
         : currentModel || 'unset';
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: history, children: (item) => _jsx(HistoryLine, { item: item }, item.id) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(InputBar, { value: input, onChange: setInput, onSubmit: handleSubmit, loading: loading }), _jsxs(Text, { children: [_jsx(Text, { color: theme.accent, children: "  /model" }), _jsxs(Text, { color: theme.muted, children: ["  ", shortModel] })] })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: history, children: (item) => _jsx(HistoryLine, { item: item }, item.id) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(InputBar, { value: input, onChange: setInput, onSubmit: handleSubmit, loading: loading }), _jsxs(Text, { children: [_jsx(Text, { color: theme.accent, children: "  /model" }), _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), _jsx(Text, { color: theme.accent, children: "/settings" }), _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), _jsx(Text, { color: theme.text, children: shortModel })] })] })] }));
 };

package/dist/ui/PermissionPrompt.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text, useInput, useStdout } from 'ink';
+import { permissions } from '../core/permission.js';
+import { theme } from './theme.js';
+export const PermissionPrompt = ({ req }) => {
+    const { stdout } = useStdout();
+    const width = Math.max(40, stdout?.columns ?? 60);
+    const inner = width - 4;
+    useInput((input, key) => {
+        if (input === 'y' || input === 'Y')
+            permissions.answer('yes');
+        else if (input === 'n' || input === 'N' || key.escape)
+            permissions.answer('no');
+        else if (input === 'a' || input === 'A')
+            permissions.answer('always');
+    });
+    const dangerColor = req.danger === 'high' ? theme.error :
+        req.danger === 'medium' ? theme.warning :
+            theme.accent;
+    const title = `${req.danger === 'high' ? '⚠  ' : ''}${req.title}`;
+    const topPad = Math.max(1, inner - title.length - 3);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '╭─ ' }), _jsx(Text, { color: dangerColor, bold: true, children: title }), _jsx(Text, { color: theme.muted, children: ' ' + '─'.repeat(topPad) + '╮' })] }), req.body.map((line, i) => {
+                const pad = Math.max(0, inner - line.length - 2);
+                return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: theme.text, children: line }), _jsx(Text, { children: ' '.repeat(pad) })] }, i));
+            }), req.diff && req.diff.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: '│' }), req.diff.map((d, i) => {
+                        const sign = d.type === 'add' ? '+' : d.type === 'remove' ? '-' : ' ';
+                        const color = d.type === 'add' ? theme.success :
+                            d.type === 'remove' ? theme.error :
+                                theme.muted;
+                        const text = `${sign} ${d.text}`.slice(0, inner - 2);
+                        const pad = Math.max(0, inner - text.length - 2);
+                        return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: color, children: text }), _jsx(Text, { children: ' '.repeat(pad) })] }, i));
+                    })] })), _jsx(Text, { color: theme.muted, children: '╰' + '─'.repeat(inner) + '╯' }), _jsxs(Text, { children: [_jsx(Text, { color: theme.success, bold: true, children: "  [y]" }), _jsx(Text, { color: theme.muted, children: " allow once   " }), _jsx(Text, { color: theme.accent, bold: true, children: "[a]" }), _jsx(Text, { color: theme.muted, children: " always (this session)   " }), _jsx(Text, { color: theme.error, bold: true, children: "[n]" }), _jsx(Text, { color: theme.muted, children: " deny" })] })] }));
+};

package/dist/ui/Settings.js

@@ -0,0 +1,143 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { KeyInput } from './KeyInput.js';
+import { getConfig, saveConfig, applyConfig } from '../core/config.js';
+import { theme } from './theme.js';
+export const Settings = ({ onClose, onModelChange }) => {
+    const { stdout } = useStdout();
+    const width = Math.max(40, stdout?.columns ?? 60);
+    const [screen, setScreen] = useState('main');
+    const [cursor, setCursor] = useState(0);
+    const [cfg, setCfg] = useState(() => getConfig());
+    const [draft, setDraft] = useState('');
+    const [testResult, setTestResult] = useState(null);
+    const persist = (next) => {
+        saveConfig(next);
+        applyConfig(next);
+        setCfg(next);
+    };
+    const mainItems = [
+        { label: 'API key', hint: cfg.apiKey ? '•••' + cfg.apiKey.slice(-4) : 'not set', action: () => setScreen('apikey') },
+        { label: 'Base URL', hint: cfg.baseUrl || 'default (OpenAI)', action: () => setScreen('baseurl') },
+        { label: 'Model', hint: cfg.model, action: () => setScreen('model') },
+        {
+            label: 'n8n',
+            hint: cfg.n8nUrl
+                ? (cfg.n8nApiKey ? `${cfg.n8nUrl} ✓` : `${cfg.n8nUrl} (no key)`)
+                : 'not configured',
+            action: () => setScreen('n8n'),
+        },
+        { label: 'Reset all config', hint: 'delete ~/.blyue/.env', action: () => setScreen('reset') },
+        { label: 'Close', hint: 'esc', action: onClose },
+    ];
+    // ---- Main menu navigation ----
+    useInput((_, key) => {
+        if (key.escape)
+            return onClose();
+        if (key.upArrow)
+            setCursor((c) => (c - 1 + mainItems.length) % mainItems.length);
+        if (key.downArrow)
+            setCursor((c) => (c + 1) % mainItems.length);
+        if (key.return)
+            mainItems[cursor].action();
+    }, { isActive: screen === 'main' });
+    // ---- n8n submenu navigation ----
+    const n8nItems = [
+        { label: 'URL', hint: cfg.n8nUrl || 'not set', action: () => { setDraft(cfg.n8nUrl || ''); setScreen('n8n-url'); } },
+        { label: 'API key', hint: cfg.n8nApiKey ? '•••' + cfg.n8nApiKey.slice(-4) : 'not set', action: () => { setDraft(cfg.n8nApiKey || ''); setScreen('n8n-key'); } },
+        { label: 'Test connection', hint: 'ping n8n API', action: async () => {
+                setScreen('n8n-test');
+                setTestResult(null);
+                try {
+                    const { n8nListWorkflows } = await import('../core/n8n.js');
+                    const wf = await n8nListWorkflows();
+                    setTestResult(`✓ Connected. ${wf.length} workflow(s) found.`);
+                }
+                catch (e) {
+                    setTestResult('✗ ' + (e?.message || String(e)));
+                }
+            } },
+        { label: 'Disable n8n', hint: 'remove URL + key', action: () => {
+                const next = { ...cfg };
+                delete next.n8nUrl;
+                delete next.n8nApiKey;
+                persist(next);
+            } },
+        { label: 'Back', hint: 'esc', action: () => setScreen('main') },
+    ];
+    const [n8nCursor, setN8nCursor] = useState(0);
+    useInput((_, key) => {
+        if (key.escape)
+            return setScreen('main');
+        if (key.upArrow)
+            setN8nCursor((c) => (c - 1 + n8nItems.length) % n8nItems.length);
+        if (key.downArrow)
+            setN8nCursor((c) => (c + 1) % n8nItems.length);
+        if (key.return)
+            n8nItems[n8nCursor].action();
+    }, { isActive: screen === 'n8n' });
+    // ---- Frame helpers ----
+    const inner = width - 4;
+    const top = (label) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '╭─ ' }), _jsx(Text, { color: theme.accent, bold: true, children: label }), _jsx(Text, { color: theme.muted, children: ' ' + '─'.repeat(Math.max(1, inner - label.length - 3)) + '╮' })] }));
+    const bot = (_jsx(Text, { color: theme.muted, children: '╰' + '─'.repeat(inner) + '╯' }));
+    const row = (content) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), content] }));
+    // ---- Screens ----
+    if (screen === 'main') {
+        return (_jsxs(Box, { flexDirection: "column", children: [top('settings'), mainItems.map((it, i) => {
+                    const active = i === cursor;
+                    return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: active ? theme.accent : theme.muted, bold: active, children: active ? '❯ ' : '  ' }), _jsx(Text, { color: active ? theme.text : theme.muted, bold: active, children: it.label.padEnd(20) }), _jsx(Text, { color: theme.muted, children: it.hint })] }, it.label));
+                }), bot, _jsx(Text, { color: theme.muted, children: "\u2191\u2193 move \u00B7 \u21B5 select \u00B7 esc close" })] }));
+    }
+    if (screen === 'apikey' || screen === 'baseurl') {
+        const isKey = screen === 'apikey';
+        const title = isKey ? 'api key' : 'base url';
+        const value = isKey ? cfg.apiKey : cfg.baseUrl || '';
+        const setValue = (v) => {
+            const next = { ...cfg, [isKey ? 'apiKey' : 'baseUrl']: v };
+            persist(next);
+        };
+        return (_jsxs(Box, { flexDirection: "column", children: [top(title), row(_jsx(Text, { color: theme.muted, children: isKey ? 'Paste your new API key' : 'e.g. https://openrouter.ai/api/v1' })), row(_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, bold: true, children: '❯ ' }), _jsx(KeyInput, { value: value, onChange: setValue, placeholder: isKey ? 'sk-...' : 'https://...', masked: isKey, onSubmit: () => setScreen('main') })] })), bot, _jsx(Text, { color: theme.muted, children: "type \u00B7 backspace \u00B7 \u21B5 save \u00B7 esc back" })] }));
+    }
+    if (screen === 'model') {
+        // Simple inline editor for now — full ModelPicker opens separately if user wants
+        return (_jsxs(Box, { flexDirection: "column", children: [top('model'), row(_jsx(Text, { color: theme.muted, children: "Type model name (or use /model for picker)" })), row(_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, bold: true, children: '❯ ' }), _jsx(KeyInput, { value: cfg.model, onChange: (v) => persist({ ...cfg, model: v }), placeholder: "gpt-4o-mini", onSubmit: () => {
+                                onModelChange?.(cfg.model);
+                                setScreen('main');
+                            } })] })), bot, _jsx(Text, { color: theme.muted, children: "type \u00B7 \u21B5 save \u00B7 esc back" })] }));
+    }
+    if (screen === 'n8n') {
+        return (_jsxs(Box, { flexDirection: "column", children: [top('n8n integration'), n8nItems.map((it, i) => {
+                    const active = i === n8nCursor;
+                    return (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: '│ ' }), _jsx(Text, { color: active ? theme.accent : theme.muted, bold: active, children: active ? '❯ ' : '  ' }), _jsx(Text, { color: active ? theme.text : theme.muted, bold: active, children: it.label.padEnd(20) }), _jsx(Text, { color: theme.muted, children: it.hint })] }, it.label));
+                }), bot, _jsx(Text, { color: theme.muted, children: "\u2191\u2193 move \u00B7 \u21B5 select \u00B7 esc back" })] }));
+    }
+    if (screen === 'n8n-url' || screen === 'n8n-key') {
+        const isKey = screen === 'n8n-key';
+        const title = isKey ? 'n8n api key' : 'n8n url';
+        const value = isKey ? cfg.n8nApiKey || '' : cfg.n8nUrl || '';
+        const setValue = (v) => {
+            const next = { ...cfg, [isKey ? 'n8nApiKey' : 'n8nUrl']: v };
+            persist(next);
+        };
+        return (_jsxs(Box, { flexDirection: "column", children: [top(title), row(_jsx(Text, { color: theme.muted, children: isKey ? 'Settings → n8n API → create key' : 'e.g. http://localhost:5678' })), row(_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, bold: true, children: '❯ ' }), _jsx(KeyInput, { value: value, onChange: setValue, placeholder: isKey ? 'n8n_api_...' : 'http://localhost:5678', masked: isKey, onSubmit: () => setScreen('n8n') })] })), bot, _jsx(Text, { color: theme.muted, children: "type \u00B7 backspace \u00B7 \u21B5 save \u00B7 esc back" })] }));
+    }
+    if (screen === 'n8n-test') {
+        useInput(() => setScreen('n8n'), { isActive: screen === 'n8n-test' });
+        return (_jsxs(Box, { flexDirection: "column", children: [top('n8n test'), row(_jsx(Text, { color: testResult?.startsWith('✓') ? theme.success : theme.muted, children: testResult || 'testing…' })), bot, _jsx(Text, { color: theme.muted, children: "press any key to go back" })] }));
+    }
+    if (screen === 'reset') {
+        return (_jsxs(Box, { flexDirection: "column", children: [top('reset config'), row(_jsx(Text, { color: theme.error, children: "Delete ~/.blyue/.env and reconfigure?" })), row(_jsx(Text, { color: theme.muted, children: "Press Y to confirm, N to cancel." })), bot] }));
+    }
+    return null;
+};
+// Handle Y/N for reset outside component main body
+export const SettingsResetHandler = ({ onConfirm, onCancel, }) => {
+    useInput((input) => {
+        if (input === 'y' || input === 'Y')
+            onConfirm();
+        if (input === 'n' || input === 'N')
+            onCancel();
+    });
+    return null;
+};

package/dist/ui/theme.js

@@ -1,8 +1,9 @@
 export const theme = {
-    accent: 'magentaBright', // the only non-neutral color
+    accent: 'cyan',
     text: 'white',
     muted: 'gray',
     dim: 'gray',
     error: 'red',
+    warning: 'yellow',
     success: 'green',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blyuecode",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "BLYUE Code — a coding agent by Lumen",
   "type": "module",
   "license": "MIT",