@xingjisoft/neutrino 0.2.1 → 0.3.0

package/README.md

@@ -22,7 +22,7 @@ A CLI coding agent that lives in your terminal. Neutrino gives you an interactiv
 - **Sub-agents** — independent work can be handed to a sub-agent: a second agent loop with its own context, its own tool calls and the same approval gate. Only its report comes back, so a survey that reads thirty files does not fill the conversation with thirty files. See [Sub-agents](#sub-agents).
 - **Agent history browser** — view past sessions from other CLI agents (Claude Code, Codex, OpenCode) directly from the history screen.
 - **Approval gate** — risky commands and paths outside the working directory need your sign-off. The header turns orange and reads **Request Approval**; press `Y` or `N`. Delete-class commands always ask, unless you explicitly granted full trust, and there is an opt-in reviewer agent for automatic decisions.
-- **Browser UI on by default** — every `neutrino` launch also mounts a local website at <http://127.0.0.1:8765> that lists every saved conversation grouped by working directory, streams the running one in real time, and lets you pause/resume it, send messages, switch provider/model/intensity, and edit settings from the browser. Use `--port`/`--host` to move it, `--lan` to share it, or `--no-web` to keep the terminal only.
+- **Browser UI on by default** — every `neutrino` launch also mounts a local website at <http://127.0.0.1:8765> that lists every saved conversation grouped by working directory, streams the running one in real time, and lets you pause/resume it, send messages, start new conversations, open or create working directories, switch provider/model/intensity, edit every terminal setting, and switch the interface between English and 简体中文. Use `--port`/`--host` to move it, `--lan` to share it, or `--no-web` to keep the terminal only.
 
 ## Requirements
 
@@ -190,7 +190,8 @@ Settings are stored under `~/.neutrino/`:
   with `"reasoning": true` (or opt out with `false`).
 - `config.json` — app configuration (selected provider/model/intensity, theme,
   language, approval mode, `auto_approve_extreme_risk`, `sound_alerts`,
-  `web_console`).
+  `web_console`, `web_workspaces`). `language` (`en` or `zh`) is the browser
+  console's interface language; the terminal UI itself stays English.
 - `session/` — saved conversation sessions, one JSON file per session.
 
 Set your API key in the model select screen or directly in `model.json`.
@@ -306,20 +307,44 @@ terminal UI starts. It groups every saved conversation by working directory
 (showing the five newest per path with the rest collapsed), folds the work of
 every finished turn into one summary line that opens on a click while the reply
 stays on screen, streams a running conversation live, and lets you pause or
-resume it and send new messages from the browser.
+resume it and send new messages from the browser. Conversation text is rendered
+as markdown — headings, lists (including tasks and nesting), tables, block
+quotes, fenced code, emphasis, links and images — while raw HTML stays inert and
+only safe link/image schemes become clickable.
+
+**New conversation** in the sidebar starts a chat that has no transcript yet.
+Its dialog chooses the working directory and the provider, model and thinking
+level for the first turn. **Browse…** opens the server's folder picker, where you
+can walk the filesystem, create a folder, and use it as the conversation's
+working directory. Opened folders are remembered under **Working directories**
+(the folder button above the list), which scopes the sidebar to that project and
+lets you start a new chat there; you can always return to **All directories**.
 
 A saved transcript opens read-only, because nothing is running for it. Press
 **Continue here** (or simply type in the composer) and the server resumes it
 in-process — same model, working directory and token counters — so you can keep
 chatting from the browser with no terminal attached. Turns are written back to
-the same session file.
+the same session file. **Clear** starts a fresh conversation in the same folder
+(the previous transcript stays saved), **Delete** removes a saved transcript,
+and **Other agents** lists read-only sessions that Claude Code, Codex or
+OpenCode recorded in that folder.
 
 Use the selectors above a conversation to change its provider, model or
 intensity, then press **Apply to conversation** (pause an active turn first).
 The **Settings** (gear) button in the sidebar edits defaults for new conversations,
-context compression and approval settings. Conversation choices are saved with
-the transcript and do not overwrite the defaults. Configured models and keys
-are shared with the terminal; keys stay on the server.
+the interface language, plan-first turns, the default approval mode, context
+compression and approval settings. Conversation choices are saved with the
+transcript and do not overwrite the defaults. Configured models and keys are
+shared with the terminal; keys stay on the server.
+
+The interface language can be switched in the sidebar footer or in
+**Settings → Interface**: English and 简体中文 are supported. The change applies
+immediately without a reload, survives restarts in `config.json`, and is shared
+by every browser. The terminal UI itself is not translated.
+
+The `ⓘ` button in a conversation header opens the same plan/token card as
+`Ctrl+P` in the terminal: the steps of a planned turn with their live statuses,
+and the prompt/completion/total token counts when no plan is running.
 
 Context auto-compression starts at 80% of the current model's context window.
 Models default to 1,000,000 tokens (compression at 800,000). Adjust the model
@@ -450,6 +475,9 @@ node scripts/test-tools.mjs      # verify tool-output folding
 node scripts/test-web.mjs        # verify the web server, API, SSE stream and path-traversal guards
 node scripts/test-web-settings.mjs # verify model switching, persistence, browser controls and defaults
 node scripts/test-web-settings-http.mjs # verify authenticated settings and model changes over HTTP
+node scripts/test-web-markdown.mjs # verify the browser markdown renderer and its XSS boundaries
+node scripts/test-web-i18n.mjs   # verify every console label has a Chinese translation and placeholders survive
+node scripts/test-web-workspaces.mjs # verify folder browsing/creation, new conversations, clear/delete and other-agent history
 ```
 
 ### Rendering model

package/dist/config.js

@@ -63,6 +63,12 @@ export const DEFAULT_MODELS = {
         },
     ],
 };
+/** Languages the browser console can render its own interface in. */
+export const WEB_LANGUAGES = ["en", "zh"];
+/** Unknown or missing values fall back to English rather than breaking the UI. */
+export function normalizeWebLanguage(value) {
+    return typeof value === "string" && value.trim().toLowerCase().startsWith("zh") ? "zh" : "en";
+}
 export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
@@ -83,6 +89,9 @@ export const DEFAULT_CONFIG = {
     // Mount the browser UI alongside the terminal UI unless it is turned off
     // here or on the command line.
     web_console: true,
+    // Working directories opened from the browser, newest first. They remain
+    // listed even when they hold no conversations yet.
+    web_workspaces: [],
     // Initialized as a salted hash of the default Web password on first use.
     web_password_hash: "",
 };

package/dist/screens/chat.js

@@ -327,6 +327,45 @@ export class ChatScreen extends Screen {
         this.app.render();
         this.publishLive();
     }
+    /**
+     * Start a fresh conversation in the same working directory. Used by Ctrl+L
+     * and by the browser's Clear button, so both screens behave identically. The
+     * previous transcript is saved first and is never overwritten.
+     */
+    liveClear() {
+        this.save();
+        if (this.saveError) {
+            this.app.render();
+            return;
+        }
+        this.turnToken++;
+        if (this.pendingApproval)
+            this.settleApproval(false);
+        this.busy = false;
+        this.paused = false;
+        this.queued = null;
+        this.compressing = false;
+        this.retryNotice = null;
+        this.app.state.isThinking = false;
+        this.lastPromptTokens = 0;
+        this.sessionId = null;
+        this.context = null;
+        this.expandedContext = false;
+        this.plan = null;
+        this.planning = false;
+        this.subagent = null;
+        const sysText = this.messages[0] && this.messages[0].role === "system" ? this.messages[0].content : "";
+        this.messages = [{ role: "system", content: sysText }];
+        this.expandedTools.clear();
+        this.finishedTurns.clear();
+        this.expandedTurns.clear();
+        this.activeTurnStart = null;
+        this.streamingContent = null;
+        this.scrollTop = 0;
+        this.followBottom = true;
+        this.publishLive();
+        this.app.render();
+    }
     liveSend(text) {
         if (!text.trim())
             return;
@@ -494,36 +533,7 @@ export class ChatScreen extends Screen {
             return;
         }
         if (key.ctrl && key.name === "l") {
-            // Clearing starts a fresh conversation; do not overwrite the old history.
-            this.save();
-            if (this.saveError) {
-                this.app.render();
-                return;
-            }
-            this.turnToken++;
-            this.busy = false;
-            this.paused = false;
-            this.queued = null;
-            this.compressing = false;
-            this.app.state.isThinking = false;
-            this.lastPromptTokens = 0;
-            this.sessionId = null;
-            this.context = null;
-            this.expandedContext = false;
-            this.plan = null;
-            this.planning = false;
-            this.subagent = null;
-            const sysText = this.messages[0] && this.messages[0].role === "system" ? this.messages[0].content : "";
-            this.messages = [{ role: "system", content: sysText }];
-            this.expandedTools.clear();
-            this.finishedTurns.clear();
-            this.expandedTurns.clear();
-            this.activeTurnStart = null;
-            this.streamingContent = null;
-            this.scrollTop = 0;
-            this.followBottom = true;
-            this.publishLive();
-            this.app.render();
+            this.liveClear();
             return;
         }
         if (key.ctrl && key.name === "u") {

package/dist/web/hub.js

@@ -175,6 +175,15 @@ class LiveHub {
         this.notify(key);
         return true;
     }
+    /** Empty a live conversation in place, keeping its key and working folder. */
+    clear(key) {
+        const entry = this.entries.get(key);
+        if (!entry?.agent.liveClear)
+            return false;
+        entry.agent.liveClear();
+        this.notify(key);
+        return true;
+    }
 }
 /** Process-wide singleton shared by the TUI and the web server. */
 export const hub = new LiveHub();

package/dist/web/server.js

@@ -16,13 +16,14 @@ import http from "node:http";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { SESSION_DIR, listSessions, resolveModelSelection } from "../config.js";
+import { SESSION_DIR, deleteSession, listSessions, loadConfig, normalizeApprovalMode, resolveModelSelection, saveConfig, } from "../config.js";
 import { getWebSettings, updateWebSettings } from "./settings.js";
 import { WebAuth } from "./auth.js";
-import { normalizeCwd } from "../cwd.js";
+import { normalizeCwd, sameCwd } from "../cwd.js";
 import { hub } from "./hub.js";
 import { writeCrashLog } from "../terminal/restore.js";
-import { resumeSession } from "./session.js";
+import { createWebSession, resumeSession } from "./session.js";
+import { listAgentSessions, loadAgentMessages } from "../agents.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // dist/web -> package root (mirrors the same trick used in config.ts).
 const PKG_ROOT = path.resolve(__dirname, "..", "..");
@@ -132,6 +133,194 @@ function loadSessionSafe(id) {
         return null;
     }
 }
+// ------------------------------------------------------- working directories
+//
+// The browser console can open any folder on this machine, which is exactly
+// what the terminal can do by being launched from that folder. Every route
+// below still sits behind the login cookie: browsing the filesystem is only as
+// exposed as the authenticated console itself.
+class ApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+function sendApiError(res, error) {
+    if (error instanceof ApiError) {
+        sendJson(res, error.status, { error: error.message, code: error.code });
+        return;
+    }
+    const message = error instanceof Error ? error.message : "invalid request";
+    sendJson(res, 400, { error: message });
+}
+const MAX_RECENT_WORKSPACES = 12;
+const AGENT_IDS = new Set(["claude", "codex", "opencode"]);
+const AGENT_SESSION_ID_RE = /^[A-Za-z0-9._-]{1,200}$/;
+/** Expand `~` and require an absolute path; used by every folder route. */
+function absolutePath(raw) {
+    if (typeof raw !== "string" || !raw.trim()) {
+        throw new ApiError(400, "working directory is required", "working directory is required");
+    }
+    let value = raw.trim();
+    if (value === "~")
+        value = os.homedir();
+    else if (/^~[\\/]/.test(value))
+        value = path.join(os.homedir(), value.slice(2));
+    if (!path.isAbsolute(value)) {
+        throw new ApiError(400, "working directory must be an absolute path", "working directory must be an absolute path");
+    }
+    return path.resolve(value);
+}
+function existingDirectory(raw) {
+    const dir = absolutePath(raw);
+    let stat;
+    try {
+        stat = fs.statSync(dir);
+    }
+    catch {
+        throw new ApiError(400, "working directory does not exist", "working directory does not exist");
+    }
+    if (!stat.isDirectory()) {
+        throw new ApiError(400, "working directory is not a folder", "working directory is not a folder");
+    }
+    return dir;
+}
+let cachedRoots = null;
+/** Filesystem roots worth offering as shortcuts (every existing drive on Windows). */
+function filesystemRoots() {
+    if (cachedRoots)
+        return cachedRoots;
+    if (process.platform !== "win32") {
+        cachedRoots = ["/"];
+        return cachedRoots;
+    }
+    const roots = [];
+    for (let code = 65; code <= 90; code += 1) {
+        const root = `${String.fromCharCode(code)}:\\`;
+        try {
+            if (fs.statSync(root).isDirectory())
+                roots.push(root);
+        }
+        catch {
+            // A drive letter that does not exist is simply not offered.
+        }
+    }
+    cachedRoots = roots.length ? roots : [path.parse(process.cwd()).root];
+    return cachedRoots;
+}
+/** One directory listing for the folder picker. Files are hidden: the picker chooses directories. */
+function readFolder(raw) {
+    const dir = existingDirectory(raw);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        throw new ApiError(403, "cannot read this folder", err instanceof Error ? err.message : "cannot read this folder");
+    }
+    const folders = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({
+        name: entry.name,
+        path: path.join(dir, entry.name),
+        hidden: entry.name.startsWith("."),
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" }));
+    const parent = path.dirname(dir);
+    return {
+        path: dir,
+        name: path.basename(dir) || dir,
+        parent: parent === dir ? null : parent,
+        separator: path.sep,
+        home: os.homedir(),
+        cwd: process.cwd(),
+        roots: filesystemRoots(),
+        entries: folders,
+    };
+}
+/** Recent working directories: explicitly opened ones first, then saved-session folders. */
+function recentWorkspacePaths() {
+    const config = loadConfig();
+    const stored = Array.isArray(config.web_workspaces)
+        ? config.web_workspaces.filter((entry) => typeof entry === "string" && entry.trim() !== "")
+        : [];
+    const saved = listSessions().map((session) => session.cwd).filter(Boolean);
+    const seen = new Set();
+    const out = [];
+    for (const dir of [...stored, ...saved, process.cwd()]) {
+        const key = normalizeCwd(dir);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(dir);
+        if (out.length >= MAX_RECENT_WORKSPACES)
+            break;
+    }
+    return out;
+}
+function workspaceList() {
+    const sessions = listSessions();
+    return recentWorkspacePaths().map((dir) => {
+        let exists = false;
+        try {
+            exists = fs.statSync(dir).isDirectory();
+        }
+        catch {
+            // A folder that disappeared stays listed, greyed out, so it can be removed by choosing another.
+        }
+        return {
+            path: dir,
+            name: path.basename(dir) || dir,
+            sessions: sessions.filter((session) => sameCwd(session.cwd, dir)).length,
+            exists,
+        };
+    });
+}
+/** Best-effort persistence: failing to remember a folder must not fail the conversation. */
+function recordWorkspace(dir) {
+    try {
+        const config = loadConfig();
+        const stored = Array.isArray(config.web_workspaces)
+            ? config.web_workspaces.filter((entry) => typeof entry === "string")
+            : [];
+        config.web_workspaces = [dir, ...stored.filter((entry) => !sameCwd(entry, dir))]
+            .slice(0, MAX_RECENT_WORKSPACES);
+        saveConfig(config);
+    }
+    catch {
+        // The picked folder still works for this conversation.
+    }
+}
+/** Create one folder inside an existing parent. */
+function createFolder(raw) {
+    const target = absolutePath(raw);
+    if (target === path.parse(target).root) {
+        throw new ApiError(400, "cannot create a folder here", "cannot create a folder here");
+    }
+    const parent = path.dirname(target);
+    if (!fs.existsSync(parent) || !fs.statSync(parent).isDirectory()) {
+        throw new ApiError(400, "parent folder does not exist", "parent folder does not exist");
+    }
+    if (fs.existsSync(target)) {
+        throw new ApiError(409, "folder already exists", "folder already exists");
+    }
+    try {
+        fs.mkdirSync(target);
+    }
+    catch (err) {
+        throw new ApiError(400, "cannot create a folder here", err instanceof Error ? err.message : "cannot create a folder here");
+    }
+    return target;
+}
+function isAgentId(value) {
+    return AGENT_IDS.has(value);
+}
+function safeAgentSessionId(id) {
+    return AGENT_SESSION_ID_RE.test(id) && !id.includes("..") && id !== "." && id !== "..";
+}
 /** Build the sidebar payload: every session grouped by working directory. */
 function buildOverview() {
     const sessions = listSessions();
@@ -178,7 +367,9 @@ function buildOverview() {
             provider: live.provider,
             intensity: live.intensity,
             cwd: live.cwd,
-            title: live.title || "New conversation",
+            // An unnamed conversation keeps an empty title: the browser translates
+            // its own fallback, and the terminal/server never impose one language.
+            title: live.title || "",
             message_count: 0,
             live: true,
             liveKey: live.key,
@@ -424,6 +615,155 @@ async function handleApi(req, res, url, auth) {
         sendJson(res, 200, { sessions: listSessions() });
         return true;
     }
+    if (pathname === "/api/workspaces") {
+        if (req.method === "GET") {
+            sendJson(res, 200, {
+                cwd: process.cwd(),
+                home: os.homedir(),
+                workspaces: workspaceList(),
+            });
+            return true;
+        }
+        if (req.method === "POST") {
+            if (!isSameOrigin(req)) {
+                sendJson(res, 403, { error: "cross-origin request rejected" });
+                return true;
+            }
+            try {
+                const body = await readJsonBody(req);
+                const dir = existingDirectory(body?.path);
+                recordWorkspace(dir);
+                sendJson(res, 200, { ok: true, path: dir, workspaces: workspaceList() });
+            }
+            catch (err) {
+                sendApiError(res, err);
+            }
+            return true;
+        }
+        sendJson(res, 405, { error: "method not allowed" });
+        return true;
+    }
+    if (pathname === "/api/fs") {
+        if (req.method !== "GET") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        try {
+            sendJson(res, 200, readFolder(url.searchParams.get("path") ?? process.cwd()));
+        }
+        catch (err) {
+            sendApiError(res, err);
+        }
+        return true;
+    }
+    if (pathname === "/api/fs/mkdir") {
+        if (req.method !== "POST") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+            return true;
+        }
+        try {
+            const body = await readJsonBody(req);
+            const created = createFolder(body?.path);
+            sendJson(res, 200, { ok: true, path: created });
+        }
+        catch (err) {
+            sendApiError(res, err);
+        }
+        return true;
+    }
+    // Start a brand-new conversation in a working directory chosen by the
+    // browser. Unlike `/continue`, there is no transcript to load first.
+    if (pathname === "/api/conversations") {
+        if (req.method !== "POST") {
+            sendJson(res, 405, { error: "method not allowed" });
+            return true;
+        }
+        if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+            return true;
+        }
+        try {
+            const body = await readJsonBody(req);
+            if (!body || typeof body !== "object" || Array.isArray(body)) {
+                throw new ApiError(400, "invalid request", "invalid request");
+            }
+            const input = body;
+            const cwd = existingDirectory(input.cwd ?? process.cwd());
+            const requested = input.selection === undefined
+                ? getWebSettings().selection
+                : input.selection;
+            const selection = resolveModelSelection(requested, false);
+            let approvalMode;
+            if (input.approval_mode !== undefined) {
+                if (input.approval_mode !== "request" && input.approval_mode !== "auto") {
+                    throw new ApiError(400, "invalid approval mode", "invalid approval mode");
+                }
+                approvalMode = normalizeApprovalMode(input.approval_mode);
+            }
+            const session = createWebSession(cwd, selection, approvalMode);
+            const key = session.start();
+            webSessions.set(key, session);
+            recordWorkspace(cwd);
+            sendJson(res, 200, { ok: true, key, cwd, snapshot: hub.snapshot(key) });
+        }
+        catch (err) {
+            sendApiError(res, err);
+        }
+        return true;
+    }
+    const deleteMatch = /^\/api\/session\/([^/]+)\/delete$/.exec(pathname);
+    if (req.method === "POST" && deleteMatch) {
+        if (!isSameOrigin(req)) {
+            sendJson(res, 403, { error: "cross-origin request rejected" });
+            return true;
+        }
+        const id = decodeURIComponent(deleteMatch[1]);
+        if (!isSafeSessionId(id)) {
+            sendJson(res, 400, { error: "invalid session id" });
+            return true;
+        }
+        if (hub.list().some((entry) => entry.sessionId === id)) {
+            sendJson(res, 409, { error: "cannot delete a running conversation" });
+            return true;
+        }
+        if (!deleteSession(id)) {
+            sendJson(res, 404, { error: "session not found" });
+            return true;
+        }
+        sendJson(res, 200, { ok: true, deleted: true });
+        return true;
+    }
+    // Read-only history recorded by other agents (Claude Code, Codex, OpenCode).
+    const agentSessionsMatch = /^\/api\/agents\/([^/]+)\/sessions$/.exec(pathname);
+    if (req.method === "GET" && agentSessionsMatch) {
+        const agent = decodeURIComponent(agentSessionsMatch[1]);
+        if (!isAgentId(agent)) {
+            sendJson(res, 400, { error: "unknown agent" });
+            return true;
+        }
+        const cwd = url.searchParams.get("cwd") || process.cwd();
+        sendJson(res, 200, { agent, cwd, sessions: listAgentSessions(agent, cwd) });
+        return true;
+    }
+    const agentSessionMatch = /^\/api\/agents\/([^/]+)\/sessions\/([^/]+)$/.exec(pathname);
+    if (req.method === "GET" && agentSessionMatch) {
+        const agent = decodeURIComponent(agentSessionMatch[1]);
+        const id = decodeURIComponent(agentSessionMatch[2]);
+        if (!isAgentId(agent)) {
+            sendJson(res, 400, { error: "unknown agent" });
+            return true;
+        }
+        if (!safeAgentSessionId(id)) {
+            sendJson(res, 400, { error: "invalid session id" });
+            return true;
+        }
+        sendJson(res, 200, { agent, id, messages: loadAgentMessages(agent, id) });
+        return true;
+    }
     const sessionMatch = /^\/api\/session\/([^/]+)$/.exec(pathname);
     if (req.method === "GET" && sessionMatch) {
         const id = decodeURIComponent(sessionMatch[1]);
@@ -499,7 +839,7 @@ async function handleApi(req, res, url, auth) {
         streamLive(decodeURIComponent(streamMatch[1]), req, res);
         return true;
     }
-    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|approval-mode))?$/.exec(pathname);
+    const liveMatch = /^\/api\/live\/([^/]+)(?:\/(pause|resume|message|approve|close|model|approval-mode|clear))?$/.exec(pathname);
     if (liveMatch) {
         const key = decodeURIComponent(liveMatch[1]);
         const action = liveMatch[2];
@@ -593,6 +933,14 @@ async function handleApi(req, res, url, auth) {
                 sendJson(res, 200, { ok: true, closed: true });
                 return true;
             }
+            if (action === "clear") {
+                if (!hub.clear(key)) {
+                    sendJson(res, 409, { error: "this session cannot be cleared" });
+                    return true;
+                }
+                sendJson(res, 200, { ok: true, snapshot: hub.snapshot(key) });
+                return true;
+            }
             // action === "message"
             let body;
             try {