nou-cli 0.5.1 → 0.5.3

package/dist/src/mcp/import.js

@@ -0,0 +1,106 @@
+import { readFileSync } from "fs";
+import os from "os";
+import path from "path";
+function json(file) {
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Keeps the fields Nou uses, from a server entry in any of these formats. */
+function normalize(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const out = {};
+    if (typeof raw.command === "string")
+        out.command = raw.command;
+    if (Array.isArray(raw.args))
+        out.args = raw.args.map(String);
+    if (raw.env && typeof raw.env === "object")
+        out.env = Object.fromEntries(Object.entries(raw.env).map(([k, v]) => [k, String(v)]));
+    if (typeof raw.cwd === "string")
+        out.cwd = raw.cwd;
+    const url = raw.url ?? raw.serverUrl ?? raw.httpUrl;
+    if (typeof url === "string")
+        out.url = url;
+    if (raw.headers && typeof raw.headers === "object")
+        out.headers = Object.fromEntries(Object.entries(raw.headers).map(([k, v]) => [k, String(v)]));
+    if (raw.disabled === true)
+        out.disabled = true;
+    return out.command || out.url ? out : null;
+}
+/** The [mcp_servers.<name>] tables of a Codex config.toml (just the keys MCP servers use). */
+export function codexServers(toml) {
+    const out = {};
+    let current = null;
+    let sub = null;
+    const value = (v) => {
+        v = v.trim();
+        if (v.startsWith("\"") || v.startsWith("'"))
+            return v.slice(1, v.lastIndexOf(v[0])).replace(/\\"/g, "\"");
+        if (v.startsWith("["))
+            return [...v.matchAll(/"((?:\\.|[^"\\])*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2]);
+        if (v.startsWith("{"))
+            return Object.fromEntries([...v.matchAll(/([\w-]+)\s*=\s*"((?:\\.|[^"\\])*)"/g)].map((m) => [m[1], m[2]]));
+        if (v === "true" || v === "false")
+            return v === "true";
+        return v;
+    };
+    for (const raw of toml.split(/\r?\n/)) {
+        const line = raw.replace(/\s+#.*$/, "").trim();
+        const table = line.match(/^\[mcp_servers\.("?)([^"\].]+)\1(?:\.(\w+))?\]$/);
+        if (table) {
+            out[table[2]] ??= {};
+            current = out[table[2]];
+            sub = table[3] ?? null;
+            if (sub)
+                current[sub] ??= {};
+            continue;
+        }
+        if (line.startsWith("[")) {
+            current = null;
+            continue;
+        }
+        const kv = line.match(/^([\w-]+)\s*=\s*(.+)$/);
+        if (current && kv)
+            (sub ? current[sub] : current)[kv[1]] = value(kv[2]);
+    }
+    return Object.fromEntries(Object.entries(out).map(([k, v]) => [k, normalize({ ...v, disabled: v.enabled === false })]).filter(([, v]) => v));
+}
+/** Every MCP server set up in the other tools on this machine (and in this project), first source wins per name. */
+export function findOtherMcpServers(home = os.homedir(), cwd = process.cwd()) {
+    const appData = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+    const claudeDesktop = process.platform === "darwin"
+        ? path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+        : process.platform === "win32" ? path.join(appData, "Claude", "claude_desktop_config.json") : path.join(home, ".config", "Claude", "claude_desktop_config.json");
+    const claudeCode = json(path.join(home, ".claude.json"));
+    const sources = [
+        { from: "Claude Code", servers: claudeCode?.mcpServers },
+        { from: "Claude Code (this project)", servers: claudeCode?.projects?.[cwd]?.mcpServers },
+        { from: "Claude Desktop", servers: json(claudeDesktop)?.mcpServers },
+        { from: "Cursor", servers: json(path.join(home, ".cursor", "mcp.json"))?.mcpServers },
+        { from: "Cursor (this project)", servers: json(path.join(cwd, ".cursor", "mcp.json"))?.mcpServers },
+        { from: "Windsurf", servers: json(path.join(home, ".codeium", "windsurf", "mcp_config.json"))?.mcpServers },
+        { from: "VS Code (this project)", servers: json(path.join(cwd, ".vscode", "mcp.json"))?.servers },
+        { from: "Gemini CLI", servers: json(path.join(home, ".gemini", "settings.json"))?.mcpServers },
+    ];
+    try {
+        sources.push({ from: "Codex", servers: codexServers(readFileSync(path.join(home, ".codex", "config.toml"), "utf-8")) });
+    }
+    catch {
+        // no Codex config
+    }
+    const found = [];
+    for (const { from, servers } of sources) {
+        if (!servers || typeof servers !== "object")
+            continue;
+        for (const [name, raw] of Object.entries(servers)) {
+            const config = normalize(raw);
+            if (config && !found.some((f) => f.name === name))
+                found.push({ name, config, from });
+        }
+    }
+    return found;
+}

package/dist/src/mcp/index.js

@@ -0,0 +1,184 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { NOU_HOME } from "../config/index.js";
+export const USER_MCP_FILE = path.join(NOU_HOME, "mcp.json");
+/** Project MCP files (only read in a folder you trust: they start programs). */
+const PROJECT_MCP_FILES = [".mcp.json", path.join(".nou", "mcp.json")];
+/** Ready-made servers: `/mcp add browser` and so on. */
+export const MCP_PRESETS = {
+    browser: { config: { command: "npx", args: ["-y", "@playwright/mcp@latest"] }, about: "control a browser: open pages, click, type, read them, take screenshots (Playwright)" },
+    fetch: { config: { command: "uvx", args: ["mcp-server-fetch"] }, about: "fetch web pages as text (needs uv)" },
+};
+function readServers(file) {
+    try {
+        const json = JSON.parse(readFileSync(file, "utf-8"));
+        const servers = json?.mcpServers ?? json?.servers ?? {};
+        return typeof servers === "object" && servers ? servers : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Every configured server: yours (~/.nou/mcp.json) and, in a trusted folder, the project's. */
+export function loadMcpServers(trusted) {
+    const out = [];
+    for (const [name, config] of Object.entries(readServers(USER_MCP_FILE)))
+        out.push({ name, config, scope: "user", file: USER_MCP_FILE });
+    if (trusted) {
+        for (const rel of PROJECT_MCP_FILES) {
+            const file = path.resolve(rel);
+            for (const [name, config] of Object.entries(readServers(file))) {
+                if (!out.some((e) => e.name === name))
+                    out.push({ name, config, scope: "project", file });
+            }
+        }
+    }
+    return out.filter((e) => e.config && (e.config.command || e.config.url));
+}
+/** Adds (or replaces) servers in ~/.nou/mcp.json. */
+export function saveUserServers(servers) {
+    let json = {};
+    try {
+        json = JSON.parse(readFileSync(USER_MCP_FILE, "utf-8"));
+    }
+    catch {
+        // a new file
+    }
+    json.mcpServers = { ...(json.mcpServers ?? {}), ...servers };
+    if (!existsSync(NOU_HOME))
+        mkdirSync(NOU_HOME, { recursive: true });
+    writeFileSync(USER_MCP_FILE, JSON.stringify(json, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(USER_MCP_FILE, 0o600); // it can hold tokens
+    }
+    catch {
+        // Windows ignores it
+    }
+}
+export function removeUserServer(name) {
+    try {
+        const json = JSON.parse(readFileSync(USER_MCP_FILE, "utf-8"));
+        if (!json.mcpServers?.[name])
+            return false;
+        delete json.mcpServers[name];
+        writeFileSync(USER_MCP_FILE, JSON.stringify(json, null, 2), { mode: 0o600 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Tool names the model sees: mcp__server__tool, in the characters every provider accepts. */
+const toolName = (server, tool) => `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64);
+/** Keeps the end of a server's stderr, to say why it failed (it never reaches the screen). */
+function tailOf(stream) {
+    let text = "";
+    stream?.on("data", (chunk) => {
+        text = (text + String(chunk)).slice(-2000);
+    });
+    return () => text.trim().split("\n").slice(-3).join(" ").slice(0, 300);
+}
+/**
+ * Connects to the MCP servers and turns their tools into tools for Nou's engine. A server's output goes to
+ * a buffer, never the terminal, so it can't scribble over Nou's screen; tools that change things ask
+ * first, like Nou's own.
+ */
+export class McpManager {
+    onChange;
+    servers = new Map();
+    constructor(onChange) {
+        this.onChange = onChange;
+    }
+    status() {
+        return [...this.servers.values()].map((s) => s.status);
+    }
+    /** Connects to every enabled server in `entries` (already connected ones are kept). */
+    async connect(entries) {
+        const wanted = new Set(entries.map((e) => e.name));
+        for (const [name, s] of this.servers) {
+            if (!wanted.has(name)) {
+                void s.client?.close().catch(() => { });
+                this.servers.delete(name);
+            }
+        }
+        await Promise.all(entries.filter((e) => !this.servers.has(e.name)).map((e) => this.start(e)));
+    }
+    async start(entry) {
+        const status = { name: entry.name, scope: entry.scope, state: entry.config.disabled ? "off" : "connecting", tools: 0 };
+        const slot = { status, tools: [] };
+        this.servers.set(entry.name, slot);
+        this.onChange();
+        if (entry.config.disabled)
+            return;
+        let stderr = () => "";
+        try {
+            const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+            const client = new Client({ name: "nou", version: "1" });
+            let transport;
+            if (entry.config.url) {
+                const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+                transport = new StreamableHTTPClientTransport(new URL(entry.config.url), entry.config.headers ? { requestInit: { headers: entry.config.headers } } : undefined);
+            }
+            else {
+                const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+                transport = new StdioClientTransport({
+                    command: entry.config.command,
+                    args: entry.config.args ?? [],
+                    // The SDK adds a safe base (PATH, HOME...) to these: your API keys aren't passed to every server.
+                    ...(entry.config.env ? { env: entry.config.env } : {}),
+                    cwd: entry.config.cwd ?? process.cwd(),
+                    stderr: "pipe",
+                });
+                stderr = tailOf(transport.stderr);
+            }
+            await withTimeout(client.connect(transport), 30_000, "didn't answer within 30 seconds");
+            const { tools } = await withTimeout(client.listTools(), 15_000, "didn't list its tools");
+            Object.assign(slot, { client, transport, tools });
+            slot.status = { ...status, state: "ready", tools: tools.length };
+        }
+        catch (error) {
+            const why = stderr();
+            slot.status = { ...status, state: "failed", error: `${error?.message ?? error}${why ? ` (${why})` : ""}` };
+        }
+        this.onChange();
+    }
+    /** The connected servers' tools, ready for the engine. */
+    tools() {
+        const out = [];
+        for (const [server, s] of this.servers) {
+            if (s.status.state !== "ready")
+                continue;
+            for (const tool of s.tools) {
+                const schema = tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : {};
+                out.push({
+                    definition: {
+                        name: toolName(server, tool.name),
+                        description: `[${server}] ${tool.description ?? tool.name}`.slice(0, 1000),
+                        parameters: { ...schema, type: "object", properties: schema.properties ?? {}, required: Array.isArray(schema.required) ? schema.required : [] },
+                    },
+                    // Only tools that say they don't change anything run without asking.
+                    readOnly: tool.annotations?.readOnlyHint === true,
+                    source: `mcp:${server}`,
+                    run: async (args) => {
+                        const result = await s.client.callTool({ name: tool.name, arguments: args }, undefined, { timeout: 180_000 });
+                        const parts = (result.content ?? []).map((c) => (c.type === "text" ? c.text : c.type === "resource" ? c.resource?.text ?? "" : `[${c.type}]`));
+                        const text = parts.join("\n").trim() || "(no output)";
+                        return result.isError ? `Error: ${text}` : text;
+                    },
+                });
+            }
+        }
+        return out;
+    }
+    close() {
+        for (const s of this.servers.values())
+            void s.client?.close().catch(() => { });
+        this.servers.clear();
+    }
+}
+function withTimeout(promise, ms, why) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(why)), ms);
+        promise.then((v) => (clearTimeout(timer), resolve(v)), (e) => (clearTimeout(timer), reject(e)));
+    });
+}

package/dist/src/providers/anthropic.js

@@ -37,6 +37,21 @@ function toAnthropic(messages) {
     }
     return out;
 }
+/**
+ * Marks the end of the conversation for prompt caching, so the next request (every tool step of a turn)
+ * reads all of it from the cache instead of paying for it again: cached input costs a tenth or less.
+ */
+function withCacheBreakpoint(params) {
+    const last = params[params.length - 1];
+    if (!last)
+        return params;
+    const content = typeof last.content === "string" ? [{ type: "text", text: last.content }] : [...last.content];
+    const end = content[content.length - 1];
+    if (!end || end.type === "thinking" || end.type === "redacted_thinking")
+        return params;
+    content[content.length - 1] = { ...end, cache_control: { type: "ephemeral" } };
+    return [...params.slice(0, -1), { ...last, content }];
+}
 function hasCredentials() {
     return !!(process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_PROFILE)
         || existsSync(path.join(os.homedir(), ".config", "anthropic"));
@@ -46,8 +61,9 @@ export function anthropicProvider() {
     let client = null;
     const getClient = () => {
         const auth = `${process.env.ANTHROPIC_API_KEY}|${process.env.ANTHROPIC_AUTH_TOKEN}|${process.env.ANTHROPIC_BASE_URL}`;
+        // No retries here: the agent retries failed requests itself (with backoff), and both would multiply.
         if (client?.auth !== auth)
-            client = { auth, api: new Anthropic() };
+            client = { auth, api: new Anthropic({ maxRetries: 0 }) };
         return client.api;
     };
     return {
@@ -65,14 +81,14 @@ export function anthropicProvider() {
             apiKey: process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || "",
             api: "anthropic-messages",
         }),
-        async chat({ model, system, messages, tools, onText, signal, effort: requested }) {
+        async chat({ model, system, messages, tools, onText, onThinking, signal, effort: requested }) {
             const fallbacks = FALLBACK_MODELS.test(model);
             const effort = EFFORT_MODELS.test(model) ? process.env.NOU_EFFORT ?? requested ?? "high" : undefined;
             const body = {
                 model,
                 max_tokens: 64000,
                 system: [{ type: "text", text: system, cache_control: { type: "ephemeral" } }],
-                messages: toAnthropic(messages),
+                messages: withCacheBreakpoint(toAnthropic(messages)),
                 tools: tools.map((t) => ({
                     name: t.name,
                     description: t.description,
@@ -80,6 +96,8 @@ export function anthropicProvider() {
                     eager_input_streaming: true,
                 })),
                 stream: true,
+                // Current models think between tool calls; summarized, that shows what they're doing instead of a silence.
+                ...(EFFORT_MODELS.test(model) ? { thinking: { type: "adaptive", display: "summarized" } } : {}),
                 ...(effort ? { output_config: { effort: effort } } : {}),
                 ...(fallbacks ? { betas: ["server-side-fallback-2026-07-01"], fallbacks: "default" } : {}),
             };
@@ -87,6 +105,8 @@ export function anthropicProvider() {
                 let text = "";
                 try {
                     const stream = getClient().beta.messages.stream(body, signal ? { signal } : {});
+                    // Thinking goes to the progress line, not the reply: it isn't kept, so it mustn't reflow the chat.
+                    stream.on("thinking", (delta) => onThinking?.(delta));
                     stream.on("text", (delta) => {
                         text += delta;
                         onText(delta);

package/dist/src/providers/index.js

@@ -27,6 +27,19 @@ export function resolveModel(spec) {
 export const describe = (choice) => `${choice.provider.id}:${choice.model}`;
 /** Whether a provider error means the API key is wrong (rather than, say, the server being down). */
 export const rejectedKey = (error) => /\b(401|403)\b|api key|unauthori[sz]ed|authentication/i.test(error);
+/**
+ * Whether an error is the provider's setup rather than the request: a rejected key, a URL that doesn't
+ * answer, or a model it doesn't have. Each has a place in settings to fix it.
+ */
+export function setupProblem(provider, error) {
+    if (rejectedKey(error) && provider.connect?.some((f) => f.secret))
+        return "key";
+    if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|getaddrinfo|fetch failed|Connection error|Invalid URL|connect ETIMEDOUT/i.test(error) && provider.connect?.some((f) => !f.secret))
+        return "url";
+    if (/model\b[^.]*\b(not found|does not exist|not exist|invalid|unknown|not available|not supported)|(invalid|unknown|no such) model|model_not_found/i.test(error))
+        return "model";
+    return null;
+}
 /**
  * For an error that says the key was rejected: which key, where it was set, and how to fix it.
  * The usual cause is a project's .env holding a key for the app rather than for Nou.

package/dist/src/providers/openai.js

@@ -52,7 +52,7 @@ export function openAICompatibleProvider(preset) {
         const url = baseURL();
         const key = apiKey();
         if (client?.url !== url || client.key !== key)
-            client = { url, key, api: new OpenAI({ baseURL: url, apiKey: key }) };
+            client = { url, key, api: new OpenAI({ baseURL: url, apiKey: key, maxRetries: 0 }) };
         return client.api;
     };
     const connect = [
@@ -73,9 +73,13 @@ export function openAICompatibleProvider(preset) {
                 return `set ${preset.keyEnv}`;
             return null;
         },
-        async chat({ model, system, messages, tools, onText, signal }) {
+        async chat({ model, system, messages, tools, onText, signal, effort }) {
+            // OpenAI's reasoning models take an effort too (named in the model id, through a gateway too). Nou's
+            // default, high, is their default, medium; xhigh and max are their high.
+            const reasoning = effort && /(^|\/)(gpt-5|o\d)/.test(model) && !/-chat|o1-(preview|mini)/.test(model) ? { low: "low", medium: "low", high: "medium" }[effort] ?? "high" : null;
             const stream = await getClient().chat.completions.create({
                 model,
+                ...(reasoning ? { reasoning_effort: reasoning } : {}),
                 messages: toOpenAI(system, messages),
                 ...(tools.length ? { tools: tools.map((t) => ({ type: "function", function: t })) } : {}),
                 stream: true,

package/dist/src/syntax/index.js

@@ -2,8 +2,8 @@ import { existsSync } from "fs";
 import { createRequire } from "module";
 import path from "path";
 import { fileURLToPath } from "url";
-import chalk from "chalk";
 import { Language, Parser } from "web-tree-sitter";
+import { themeColors } from "./themes.js";
 /** File extension -> grammar name (tree-sitter-<name>.wasm). Only these are shipped with Nou. */
 const GRAMMARS = {
     ".ts": "typescript", ".mts": "typescript", ".cts": "typescript", ".tsx": "tsx",
@@ -30,6 +30,11 @@ let init = null;
 const languages = new Map();
 let parser = null;
 const listeners = new Set();
+/** Tells views to re-highlight (a grammar or the fallback highlighter just loaded). */
+export function notifySyntaxLoaded() {
+    for (const l of listeners)
+        l();
+}
 /** Called when a grammar finishes loading, so views can re-highlight. */
 export function onGrammarLoaded(listener) {
     listeners.add(listener);
@@ -51,8 +56,7 @@ function load(name) {
         if (!dir)
             throw new Error("grammars not found");
         languages.set(name, await Language.load(path.join(dir, `tree-sitter-${name}.wasm`)));
-        for (const l of listeners)
-            l();
+        notifySyntaxLoaded();
     })
         .catch(() => languages.set(name, "failed"));
 }
@@ -87,20 +91,6 @@ export function preload(file) {
     if (name)
         load(name);
 }
-// --- highlighting --------------------------------------------------------------
-const COLORS = {
-    keyword: chalk.hex("#bb9af7"),
-    string: chalk.hex("#9ece6a"),
-    number: chalk.hex("#ff9e64"),
-    comment: chalk.hex("#565f89").italic,
-    type: chalk.hex("#2ac3de"),
-    func: chalk.hex("#7aa2f7"),
-    property: chalk.hex("#73daca"),
-    constant: chalk.hex("#ff9e64"),
-    tag: chalk.hex("#f7768e"),
-    punctuation: chalk.hex("#89ddff"),
-    plain: chalk.hex("#c0caf5"),
-};
 const STRINGS = /^(string|template_string|string_fragment|string_content|raw_string_literal|interpreted_string_literal|char_literal|character_literal|escape_sequence|string_literal|heredoc_body)$/;
 const NUMBERS = /^(number|integer|float|integer_literal|float_literal|number_literal|decimal_integer_literal|decimal_floating_point_literal)$/;
 const TYPES = /^(type_identifier|predefined_type|primitive_type|builtin_type|type)$/;
@@ -178,11 +168,11 @@ export function highlightTree(file, text) {
             const node = cursor.currentNode;
             if (node.childCount === 0 || node.type.includes("comment") || (isString(node) && !hasSubstitution(node))) {
                 if (node.startIndex >= pos) {
-                    out += COLORS.plain(text.slice(pos, node.startIndex));
+                    out += themeColors().plain(text.slice(pos, node.startIndex));
                     const color = colorFor(node);
                     const span = text.slice(node.startIndex, node.endIndex);
                     // Color each line separately so styles don't bleed across line breaks.
-                    out += span.split("\n").map((part) => (color ? COLORS[color](part) : COLORS.plain(part))).join("\n");
+                    out += span.split("\n").map((part) => (color ? themeColors()[color](part) : themeColors().plain(part))).join("\n");
                     pos = node.endIndex;
                 }
             }
@@ -194,7 +184,7 @@ export function highlightTree(file, text) {
     };
     if (cursor.gotoFirstChild())
         visit();
-    out += COLORS.plain(text.slice(pos));
+    out += themeColors().plain(text.slice(pos));
     tree.delete();
     return out.split("\n");
 }

package/dist/src/syntax/themes.js

@@ -0,0 +1,57 @@
+import chalk, {} from "chalk";
+/** Well-known editor themes; one-dark is the default because it reads well on most dark terminals. */
+const PALETTES = {
+    "one-dark": {
+        keyword: "#c678dd", string: "#98c379", number: "#d19a66", comment: "#7f848e", type: "#e5c07b", func: "#61afef",
+        property: "#e06c75", constant: "#d19a66", tag: "#e06c75", punctuation: "#abb2bf", plain: "#d7dae0",
+    },
+    "tokyo-night": {
+        keyword: "#bb9af7", string: "#9ece6a", number: "#ff9e64", comment: "#737aa2", type: "#2ac3de", func: "#7aa2f7",
+        property: "#73daca", constant: "#ff9e64", tag: "#f7768e", punctuation: "#89ddff", plain: "#c0caf5",
+    },
+    "github-dark": {
+        keyword: "#ff7b72", string: "#a5d6ff", number: "#79c0ff", comment: "#8b949e", type: "#ffa657", func: "#d2a8ff",
+        property: "#79c0ff", constant: "#79c0ff", tag: "#7ee787", punctuation: "#c9d1d9", plain: "#e6edf3",
+    },
+    dracula: {
+        keyword: "#ff79c6", string: "#f1fa8c", number: "#bd93f9", comment: "#8a94c4", type: "#8be9fd", func: "#50fa7b",
+        property: "#66d9ef", constant: "#bd93f9", tag: "#ff79c6", punctuation: "#f8f8f2", plain: "#f8f8f2",
+    },
+    "high-contrast": {
+        keyword: "#ff9cf5", string: "#a6ff8f", number: "#ffd27f", comment: "#b0b0b0", type: "#7fe7ff", func: "#8fc7ff",
+        property: "#ffb38a", constant: "#ffd27f", tag: "#ff8a8a", punctuation: "#ffffff", plain: "#ffffff",
+    },
+    "github-light": {
+        keyword: "#cf222e", string: "#0a3069", number: "#0550ae", comment: "#6e7781", type: "#953800", func: "#8250df",
+        property: "#0550ae", constant: "#0550ae", tag: "#116329", punctuation: "#24292f", plain: "#24292f",
+    },
+};
+const paint = (palette) => Object.fromEntries(Object.entries(palette).map(([role, hex]) => [role, role === "comment" ? chalk.hex(hex).italic : chalk.hex(hex)]));
+let current = "one-dark";
+let colors = paint(PALETTES[current]);
+let version = 0;
+/** The chalk styles for the current theme. */
+export const themeColors = () => colors;
+/** Changes whenever the theme does, so cached highlighting can be redone. */
+export const themeVersion = () => version;
+export function setCodeTheme(theme) {
+    if (theme === current || !PALETTES[theme])
+        return;
+    current = theme;
+    colors = paint(PALETTES[theme]);
+    version++;
+}
+/** The same colors for highlight.js (cli-highlight), used for languages tree-sitter doesn't cover. */
+export function highlightJsTheme() {
+    const c = colors;
+    return {
+        keyword: c.keyword, built_in: c.type, type: c.type, literal: c.constant, number: c.number, regexp: c.string,
+        string: c.string, subst: c.plain, symbol: c.constant, class: c.type, function: c.func, title: c.func, params: c.plain,
+        comment: c.comment, doctag: c.comment, meta: c.comment, "meta-keyword": c.keyword, "meta-string": c.string,
+        section: c.func, tag: c.tag, name: c.tag, "builtin-name": c.type, attr: c.property, attribute: c.property,
+        variable: c.plain, bullet: c.punctuation, code: c.string, emphasis: c.plain.italic, strong: c.plain.bold,
+        formula: c.plain, link: c.func, quote: c.comment, "selector-tag": c.tag, "selector-id": c.func, "selector-class": c.func,
+        "selector-attr": c.property, "selector-pseudo": c.property, "template-tag": c.keyword, "template-variable": c.plain,
+        addition: c.string, deletion: c.tag, default: c.plain,
+    };
+}

package/dist/src/terminal/index.js

@@ -0,0 +1,127 @@
+import { spawn } from "child_process";
+import { existsSync, statSync } from "fs";
+import os from "os";
+import path from "path";
+import { stripVTControlCharacters } from "util";
+import { stopProcess } from "../commands/index.js";
+/** Lines of output kept (the oldest go first). */
+const KEEP = 3000;
+/**
+ * The terminal panel's shell: runs what you type with your shell in the folder you've `cd`'d to, and
+ * keeps the output. Each command is its own process (no native pseudo-terminal), so full-screen programs
+ * like vim won't draw, but builds, tests, git and servers work, and what you type while one runs goes
+ * to it.
+ */
+export class Shell {
+    onChange;
+    lines = [];
+    cwd = process.cwd();
+    child = null;
+    /** The line being written (output without its newline yet; a \r starts it over, like progress bars). */
+    partial = "";
+    constructor(onChange) {
+        this.onChange = onChange;
+        process.once("exit", () => this.interrupt()); // nothing it started is left running after Nou
+    }
+    get running() {
+        return !!this.child;
+    }
+    /** Runs a command line; `cd` and `clear` are handled here so they stick. */
+    run(command) {
+        const line = command.trim();
+        if (!line)
+            return;
+        if (this.child)
+            return this.input(command);
+        this.push({ text: `${this.prompt()}${line}`, kind: "command" });
+        if (line === "clear" || line === "cls") {
+            this.lines = [];
+            return this.onChange();
+        }
+        const cd = /^cd(?:\s+(.*))?$/.exec(line);
+        if (cd)
+            return this.changeDir(cd[1]?.trim().replace(/^["']|["']$/g, "") || os.homedir());
+        const posix = process.platform !== "win32";
+        const child = spawn(line, {
+            cwd: this.cwd,
+            shell: posix ? process.env.SHELL || true : true,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: posix, // its own process group, so Ctrl+C stops everything it started
+            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+        });
+        this.child = child;
+        const write = (chunk) => this.write(chunk.toString("utf-8"));
+        child.stdout?.on("data", write);
+        child.stderr?.on("data", write);
+        child.stdin?.on("error", () => { }); // it may exit before reading what you typed
+        child.on("error", (error) => this.push({ text: error.message, kind: "error" }));
+        child.on("close", (code, signal) => {
+            this.flush();
+            if (signal)
+                this.push({ text: "stopped", kind: "info" });
+            else if (code)
+                this.push({ text: `exit ${code}`, kind: "error" });
+            this.child = null;
+            this.onChange();
+        });
+        this.onChange();
+    }
+    /** Text for the running command's input (it gets a newline, like pressing Enter in a terminal). */
+    input(text) {
+        if (!this.child?.stdin?.writable)
+            return;
+        this.push({ text, kind: "command" });
+        this.child.stdin.write(`${text}\n`);
+    }
+    /** Ctrl+C: stops the running command. */
+    interrupt() {
+        if (this.child)
+            stopProcess(this.child);
+    }
+    clear() {
+        this.lines = [];
+        this.partial = "";
+        this.onChange();
+    }
+    dispose() {
+        this.interrupt();
+    }
+    prompt() {
+        const home = os.homedir();
+        const where = this.cwd === home ? "~" : this.cwd.startsWith(home + path.sep) ? `~${this.cwd.slice(home.length)}` : this.cwd;
+        return `${where.length > 30 ? `…${path.sep}${path.basename(where)}` : where} $ `;
+    }
+    changeDir(target) {
+        const next = path.resolve(this.cwd, target.startsWith("~") ? path.join(os.homedir(), target.slice(1)) : target);
+        if (!existsSync(next) || !statSync(next).isDirectory())
+            this.push({ text: `cd: no such folder: ${target}`, kind: "error" });
+        else
+            this.cwd = next;
+        this.onChange();
+    }
+    write(text) {
+        const parts = stripVTControlCharacters(text).replace(/\r\n/g, "\n").split("\n");
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            // A carriage return goes back to the start of the line: what follows replaces it.
+            this.partial = part.includes("\r") ? part.slice(part.lastIndexOf("\r") + 1) || this.partial : this.partial + part;
+            if (i < parts.length - 1)
+                this.flush(true);
+        }
+        this.onChange();
+    }
+    flush(always = false) {
+        if (this.partial || always)
+            this.push({ text: this.partial.replace(/\t/g, "  "), kind: "out" });
+        this.partial = "";
+    }
+    /** The output so far, with the line still being written. */
+    view() {
+        return this.partial ? [...this.lines, { text: this.partial, kind: "out" }] : this.lines;
+    }
+    push(line) {
+        this.lines.push(line);
+        if (this.lines.length > KEEP)
+            this.lines.splice(0, this.lines.length - KEEP);
+    }
+}