@xingjisoft/neutrino 0.1.3 → 0.1.5

package/dist/web/session.js

@@ -0,0 +1,572 @@
+/**
+ * Headless conversation runner for the web UI.
+ *
+ * The TUI keeps its agent loop inside `ChatScreen`, glued to the renderer. The
+ * browser needs the same behaviour without a terminal, so this module resumes a
+ * saved transcript from disk and runs turns against the configured model:
+ * stream, execute tools, auto-compress, persist.
+ *
+ * A `WebSession` looks exactly like a TUI session from the outside: it
+ * registers itself in the live hub, so the regular `/api/live/*` endpoints
+ * (snapshot, stream, pause, resume, message) work unchanged.
+ */
+import { findModel, contextCompressionThreshold, loadConfig, normalizeApprovalMode, loadModels, loadPrompt, saveSession, } from "../config.js";
+import { COMPACT_KEEP, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
+import { LLMClient, describeError } from "../llm/client.js";
+import { executeTool, getToolDefinitions } from "../llm/tools.js";
+import { assessToolCall } from "../llm/risk.js";
+import { ApprovalGate, captureApprovalContext, describeApprovalIntent } from "../llm/approval.js";
+import { SessionCheckpoint } from "../persistence.js";
+import { writeCrashLog } from "../terminal/restore.js";
+import { hub, liveApprovalDetails, } from "./hub.js";
+/** Drop a resumed conversation nobody touched for this long. */
+const IDLE_DISPOSE_MS = 30 * 60 * 1000;
+/** Upper bound on tool round-trips inside a single turn. */
+const MAX_TOOL_ROUNDS = 24;
+/** Placeholder shown while a tool is still running. */
+const TOOL_PENDING = "…";
+/** Marker for the model-only summary, separate from the original transcript. */
+const SUMMARY_PREFIX = "Context was compressed. Summary of the earlier part:";
+function parseArguments(raw) {
+    const text = raw?.trim() ?? "";
+    if (!text)
+        return {};
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object")
+            return parsed;
+    }
+    catch {
+        // Hand the raw payload over instead of failing the whole turn.
+        return { value: text };
+    }
+    return { value: text };
+}
+/**
+ * Look up the model recorded in the transcript. Returns a readable error
+ * instead of throwing, so the HTTP layer can answer with a clean 4xx.
+ */
+export function resolveModel(modelName, providerName) {
+    const providers = loadModels().providers ?? [];
+    const scoped = providers.find((p) => p.name === providerName);
+    const model = scoped?.models?.find((m) => m.name === modelName);
+    if (!model) {
+        return { ok: false, error: `model "${modelName}" is not configured any more` };
+    }
+    if (!model.api_key || !model.api_key.trim()) {
+        return { ok: false, error: `model "${modelName}" has no API key configured` };
+    }
+    return { ok: true, model };
+}
+/** Build a web session from a saved transcript, or explain why we cannot. */
+export function resumeSession(source, selection) {
+    const updated = selection ? { ...source, ...selection } : source;
+    const resolved = resolveModel(updated.model, updated.provider);
+    if (!resolved.ok)
+        return resolved;
+    return { ok: true, session: new WebSession(updated, resolved.model) };
+}
+export class WebSession {
+    key = null;
+    model;
+    provider;
+    intensity;
+    dir;
+    tokens;
+    messages;
+    sessionId;
+    busy = false;
+    approvalMode;
+    paused = false;
+    queued = null;
+    compressing = false;
+    context = null;
+    streamingContent = null;
+    saveError = null;
+    checkpoint = new SessionCheckpoint(() => {
+        const saved = this.writeSession();
+        this.publishLive();
+        return saved;
+    });
+    turnToken = 0;
+    lastPromptTokens = 0;
+    disposed = false;
+    idleTimer = null;
+    /** Non-null while a tool call waits for the browser to answer. */
+    pendingApproval = null;
+    /** Reviewer count while an automated review runs, null otherwise. */
+    reviewing = null;
+    constructor(source, model) {
+        this.model = model;
+        this.approvalMode = normalizeApprovalMode(source.approval_mode ?? loadConfig().approval_mode);
+        this.provider = source.provider;
+        this.intensity = source.intensity;
+        this.dir = source.cwd;
+        this.sessionId = source.id;
+        this.messages = source.messages.slice();
+        this.context = normalizeContext(source.context, this.messages.filter((m) => m.role !== "system").length);
+        this.tokens = {
+            prompt: source.tokens?.prompt ?? 0,
+            completion: source.tokens?.completion ?? 0,
+        };
+    }
+    /** Register with the live hub so the browser can watch this conversation. */
+    start() {
+        this.checkpoint.register();
+        this.key = hub.register(this);
+        this.save();
+        this.touch();
+        this.publishLive();
+        return this.key;
+    }
+    /** Detach from the hub. The transcript stays on disk. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.turnToken++;
+        this.busy = false;
+        if (this.pendingApproval) {
+            this.pendingApproval.resolve(false);
+            this.pendingApproval = null;
+        }
+        this.clearIdleTimer();
+        this.checkpoint.dispose();
+        hub.unregister(this.key);
+        this.key = null;
+    }
+    // ---- LiveAgent -------------------------------------------------------
+    liveCwd() {
+        return this.dir;
+    }
+    liveConfigure(selection) {
+        if (this.disposed)
+            return { ok: false, error: "this session has ended" };
+        if (this.busy || this.pendingApproval) {
+            return { ok: false, error: "pause the current turn before changing models" };
+        }
+        this.model = { ...selection.model };
+        this.provider = selection.provider;
+        this.intensity = selection.intensity;
+        this.save();
+        this.publishLive();
+        return { ok: true };
+    }
+    liveMeta() {
+        return {
+            sessionId: this.sessionId,
+            title: this.title(),
+            provider: this.provider,
+            model: this.model.name,
+            intensity: this.intensity,
+            approvalMode: this.approvalMode,
+            busy: this.busy,
+            paused: this.paused,
+            queued: this.queued,
+            compressing: this.compressing,
+            saveError: this.saveError,
+            tokens: { prompt: this.tokens.prompt, completion: this.tokens.completion },
+            approval: this.pendingApproval
+                ? liveApprovalDetails(this.pendingApproval.tool, this.pendingApproval.args, this.pendingApproval.risk, this.dir)
+                : null,
+            reviewing: this.reviewing,
+        };
+    }
+    liveSnapshot(key) {
+        const messages = [];
+        for (const message of this.messages) {
+            if (message.role === "tool") {
+                messages.push({
+                    role: "tool",
+                    name: message.name,
+                    arguments: message.arguments,
+                    result: message.result,
+                });
+            }
+            else if (message.role === "summary") {
+                messages.push({ role: "summary", content: message.content, count: message.count });
+            }
+            else if (message.role === "user" || message.role === "assistant") {
+                messages.push({ role: message.role, content: message.content });
+            }
+        }
+        return {
+            ...this.liveMeta(),
+            key,
+            cwd: this.dir,
+            messages,
+            streamingContent: this.streamingContent,
+            context: this.context,
+        };
+    }
+    livePause() {
+        if (this.paused || (!this.busy && !this.queued))
+            return;
+        this.paused = true;
+        this.turnToken++;
+        // A queued decision would otherwise keep the promise (and the gate) alive.
+        if (this.pendingApproval) {
+            const pending = this.pendingApproval;
+            this.pendingApproval = null;
+            pending.resolve(false);
+        }
+        this.busy = false;
+        this.retainStreamingContent();
+        this.save();
+        this.publishLive();
+    }
+    liveResume() {
+        if (!this.paused)
+            return;
+        this.paused = false;
+        this.publishLive();
+        this.maybeFlushQueue();
+    }
+    liveSend(text) {
+        this.send(text);
+    }
+    liveApprove(approved) {
+        const pending = this.pendingApproval;
+        if (!pending)
+            return false;
+        this.pendingApproval = null;
+        pending.resolve(approved);
+        this.publishLive();
+        return true;
+    }
+    liveSetApprovalMode(mode) {
+        if (this.approvalMode === mode)
+            return;
+        this.approvalMode = mode;
+        const pending = this.pendingApproval;
+        if (pending) {
+            this.pendingApproval = null;
+            pending.resolve(null);
+        }
+        this.touch();
+        this.save();
+        this.publishLive();
+    }
+    // ---- turn driving ----------------------------------------------------
+    send(text) {
+        const trimmed = text.trim();
+        if (!trimmed || this.disposed)
+            return;
+        this.touch();
+        this.messages.push({ role: "user", content: trimmed });
+        this.save();
+        if (this.busy || this.paused) {
+            this.queued = trimmed;
+            this.publishLive();
+            return;
+        }
+        this.publishLive();
+        this.startTurn();
+    }
+    maybeFlushQueue() {
+        if (!this.queued || this.busy || this.paused)
+            return;
+        this.queued = null;
+        this.publishLive();
+        this.startTurn();
+    }
+    startTurn() {
+        const turnMessages = this.messages.slice();
+        const approvalContext = captureApprovalContext(turnMessages);
+        this.busy = true;
+        const token = ++this.turnToken;
+        this.streamingContent = "";
+        this.publishLive();
+        void (async () => {
+            await this.autoCompress(token);
+            if (token !== this.turnToken || this.paused)
+                return;
+            await this.agentLoop(this.buildApiMessages(turnMessages), token, approvalContext);
+        })().catch((err) => {
+            if (token === this.turnToken)
+                this.failTurn(err);
+        });
+    }
+    /** Ends a turn whose floating promise rejected, instead of crashing the app. */
+    failTurn(err) {
+        this.retainStreamingContent();
+        this.messages.push({ role: "assistant", content: `[Error: ${describeError(err)}]` });
+        this.streamingContent = null;
+        try {
+            this.onTurnFinished();
+        }
+        catch {
+            this.busy = false;
+            this.paused = false;
+        }
+    }
+    buildApiMessages(messages = this.messages) {
+        const api = [{ role: "system", content: loadPrompt() }];
+        for (const m of modelHistory(messages, this.context)) {
+            if (m.role === "user" || m.role === "assistant") {
+                api.push({ role: m.role, content: m.content });
+            }
+            else if (m.role === "summary") {
+                api.push({ role: "assistant", content: m.content });
+            }
+        }
+        return api;
+    }
+    async agentLoop(apiMessages, token, approvalContext) {
+        const tools = getToolDefinitions();
+        try {
+            for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+                if (token !== this.turnToken || this.paused)
+                    return;
+                const client = new LLMClient(this.model, this.provider, this.intensity);
+                let text = "";
+                this.streamingContent = "";
+                this.publishLive();
+                for await (const chunk of client.streamTurn(apiMessages, tools)) {
+                    if (token !== this.turnToken || this.paused)
+                        return;
+                    text += chunk;
+                    this.streamingContent = text;
+                    this.checkpoint.schedule();
+                    this.publishLive();
+                }
+                if (token !== this.turnToken || this.paused)
+                    return;
+                this.streamingContent = null;
+                if (client.usage) {
+                    this.tokens.prompt += client.usage.prompt;
+                    this.tokens.completion += client.usage.completion;
+                    this.lastPromptTokens = client.usage.prompt;
+                }
+                if (text.trim()) {
+                    this.messages.push({ role: "assistant", content: text });
+                    apiMessages.push({ role: "assistant", content: text });
+                }
+                this.save();
+                this.publishLive();
+                const toolCalls = client.toolCalls;
+                if (toolCalls.length === 0)
+                    break;
+                for (const call of toolCalls) {
+                    if (token !== this.turnToken || this.paused)
+                        return;
+                    const args = parseArguments(call.arguments);
+                    const toolMsg = {
+                        role: "tool",
+                        name: call.name,
+                        arguments: args,
+                        result: TOOL_PENDING,
+                    };
+                    this.messages.push(toolMsg);
+                    this.save();
+                    this.publishLive();
+                    const decision = await this.requestApproval(call.name, args, {
+                        ...approvalContext,
+                        context: captureApprovalContext(apiMessages).context,
+                    });
+                    if (token !== this.turnToken || this.paused)
+                        return;
+                    if (!decision.approved) {
+                        // A malformed request was never shown to anyone, so there is no
+                        // verdict to respect and the right move is a corrected retry.
+                        const denied = decision.source === "input"
+                            ? `[Not executed: ${decision.reason}]`
+                            : `[Not executed: approval denied (${decision.source}): ${decision.reason}] ` +
+                                describeApprovalIntent(approvalContext) +
+                                "Do not retry this call unchanged; ask the user how to proceed.";
+                        toolMsg.result = denied;
+                        apiMessages.push({ role: "tool", content: denied, tool_call_id: call.id });
+                        this.save();
+                        this.publishLive();
+                        continue;
+                    }
+                    let result;
+                    try {
+                        result = await executeTool(call.name, args, this.dir);
+                    }
+                    catch (err) {
+                        result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                    }
+                    if (this.disposed)
+                        return;
+                    toolMsg.result = result;
+                    this.save();
+                    if (token !== this.turnToken || this.paused)
+                        return;
+                    apiMessages.push({ role: "tool", content: result, tool_call_id: call.id });
+                    this.publishLive();
+                }
+                this.save();
+            }
+            this.onTurnFinished();
+        }
+        catch (err) {
+            if (token !== this.turnToken)
+                return;
+            if (this.streamingContent) {
+                this.messages.push({ role: "assistant", content: this.streamingContent });
+            }
+            this.streamingContent = null;
+            this.messages.push({
+                role: "assistant",
+                content: `[Error: ${err instanceof Error ? err.message : String(err)}]`,
+            });
+            this.onTurnFinished();
+        }
+    }
+    onTurnFinished() {
+        this.busy = false;
+        this.paused = false;
+        this.streamingContent = null;
+        this.save();
+        this.publishLive();
+        if (this.queued && !this.paused)
+            this.maybeFlushQueue();
+        else
+            this.touch();
+    }
+    // ---- approval gate ---------------------------------------------------
+    /** Classify a tool call and, when it is risky, wait for a decision. */
+    async requestApproval(tool, args, context = captureApprovalContext(this.messages)) {
+        const risk = assessToolCall(tool, args, this.dir);
+        if (!risk)
+            return { approved: true, source: "prompt", reason: "routine call" };
+        const gate = new ApprovalGate({
+            askHuman: () => new Promise((resolve) => {
+                this.pendingApproval = { tool, args, risk, resolve };
+                this.publishLive();
+            }),
+            reviewer: () => this.reviewerModel(),
+            autoApprovalEnabled: () => this.approvalMode === "auto",
+            extremeAutoApprovalEnabled: () => loadConfig().auto_approve_extreme_risk === true,
+            onReview: (info) => {
+                this.reviewing = info
+                    ? {
+                        total: info.total, round: info.round ?? 1, rounds: info.rounds ?? 1,
+                        request: liveApprovalDetails(tool, args, risk, this.dir),
+                    }
+                    : null;
+                this.publishLive();
+            },
+        });
+        return gate.decide({ tool, args, cwd: this.dir, ...context, risk });
+    }
+    /** Reviewer model: `approval_model` when set, otherwise the chat model. */
+    reviewerModel() {
+        const name = String(loadConfig().approval_model ?? "").trim();
+        const found = name ? findModel(name) : null;
+        if (found) {
+            const usable = resolveModel(found.model.name, found.provider);
+            if (usable.ok) {
+                return { model: usable.model, provider: found.provider, intensity: this.intensity };
+            }
+        }
+        return { model: this.model, provider: this.provider, intensity: this.intensity };
+    }
+    // ---- compression -----------------------------------------------------
+    compressThreshold() {
+        return contextCompressionThreshold(this.provider, this.model);
+    }
+    async autoCompress(token) {
+        const threshold = this.compressThreshold();
+        if (threshold <= 0 || this.lastPromptTokens < threshold)
+            return;
+        const visible = this.messages.filter((m) => m.role !== "system");
+        const flat = modelHistory(this.messages, this.context).map((m) => m.role === "tool"
+            ? { role: "tool", name: m.name, content: m.result }
+            : { role: m.role, content: m.content });
+        const plan = planCompaction(flat, COMPACT_KEEP);
+        if (!plan)
+            return;
+        const end = visible.length - plan.tail.length;
+        if (end <= (this.context?.end ?? 0))
+            return;
+        const snapshotLen = this.messages.length;
+        const transcript = transcriptFor(plan.head);
+        this.compressing = true;
+        this.publishLive();
+        let summary = "";
+        try {
+            summary = await new LLMClient(this.model, this.provider, this.intensity).summarize(transcript);
+        }
+        catch {
+            summary = "";
+        }
+        this.compressing = false;
+        this.publishLive();
+        if (token !== this.turnToken || this.paused)
+            return;
+        if (this.messages.length !== snapshotLen)
+            return;
+        const content = summary.trim()
+            ? `${SUMMARY_PREFIX}\n\n${summary.trim()}`
+            : "Earlier messages are preserved in history, but could not be summarized for this request.";
+        this.context = { end, summary: content };
+        this.lastPromptTokens = 0;
+        this.save();
+        this.publishLive();
+    }
+    // ---- persistence -----------------------------------------------------
+    title() {
+        for (const m of this.messages) {
+            if (m.role === "user") {
+                const line = m.content.trim().split(/\r?\n/)[0] ?? "";
+                return line.length > 80 ? `${line.slice(0, 77)}…` : line;
+            }
+        }
+        return "Resumed chat";
+    }
+    retainStreamingContent() {
+        if (this.streamingContent) {
+            this.messages.push({ role: "assistant", content: this.streamingContent });
+        }
+        this.streamingContent = null;
+    }
+    save() {
+        this.checkpoint.flush();
+    }
+    writeSession() {
+        const chat = [];
+        for (const m of this.messages) {
+            if (m.role === "user" || m.role === "assistant" || m.role === "tool")
+                chat.push(m);
+            else if (m.role === "summary")
+                chat.push({ role: "assistant", content: m.content });
+        }
+        if (this.streamingContent)
+            chat.push({ role: "assistant", content: this.streamingContent });
+        if (chat.length === 0)
+            return true;
+        try {
+            this.sessionId = saveSession(chat, this.model.name, this.provider, this.intensity, this.dir, this.sessionId, this.tokens, this.context, this.approvalMode);
+            this.saveError = null;
+            return true;
+        }
+        catch (err) {
+            const detail = describeError(err);
+            if (this.saveError === null)
+                writeCrashLog("save session", err);
+            this.saveError = detail;
+            return false;
+        }
+    }
+    publishLive() {
+        if (this.key)
+            hub.notify(this.key);
+    }
+    touch() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(() => {
+            if (!this.busy && !this.queued)
+                this.dispose();
+        }, IDLE_DISPOSE_MS);
+        if (typeof this.idleTimer.unref === "function")
+            this.idleTimer.unref();
+    }
+    clearIdleTimer() {
+        if (!this.idleTimer)
+            return;
+        clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+    }
+}

package/dist/web/settings.js

@@ -0,0 +1,101 @@
+import { DEFAULT_CONFIG, INTENSITY_LEVELS, contextWindow, isContextWindow, loadConfig, loadModels, resolveModelSelection, saveConfig, saveModels, } from "../config.js";
+import { hashWebPassword, validateWebPassword } from "./auth.js";
+/** Public settings use a whitelist: API keys and cached credentials stay on disk. */
+export function getWebSettings() {
+    const config = { ...DEFAULT_CONFIG, ...loadConfig() };
+    const providers = loadModels().providers.map((provider) => ({
+        name: provider.name,
+        models: provider.models.map((model) => ({ name: model.name, configured: Boolean(model.api_key?.trim()), context_window: contextWindow(model.context_window) })),
+    }));
+    const preferred = providers.find((p) => p.name === config.selected_provider);
+    const provider = preferred ?? providers.find((p) => p.models.some((m) => m.configured)) ?? providers[0];
+    const model = provider?.models.find((m) => m.name === config.selected_model) ??
+        provider?.models.find((m) => m.configured) ?? provider?.models[0];
+    const intensity = String(config.selected_intensity ?? config.default_intensity);
+    return {
+        providers,
+        intensities: INTENSITY_LEVELS,
+        selection: {
+            provider: provider?.name ?? "",
+            model: model?.name ?? "",
+            intensity: INTENSITY_LEVELS.includes(intensity) ? intensity : "High",
+        },
+        settings: {
+            default_intensity: String(config.default_intensity),
+            model_context_window: model?.context_window ?? contextWindow(undefined),
+            approval_model: String(config.approval_model ?? ""),
+            auto_approve_extreme_risk: config.auto_approve_extreme_risk === true,
+            sound_alerts: config.sound_alerts !== false,
+        },
+    };
+}
+/** Validate the complete patch before writing anything, preserving unrelated settings. */
+export function updateWebSettings(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid settings body");
+    const body = value;
+    if (Object.keys(body).some((key) => key !== "selection" && key !== "settings"))
+        throw new Error("unknown settings field");
+    const config = loadConfig();
+    if (body.settings !== undefined) {
+        if (!body.settings || typeof body.settings !== "object" || Array.isArray(body.settings))
+            throw new Error("invalid settings");
+        const patch = body.settings;
+        for (const [key, val] of Object.entries(patch)) {
+            if (key === "default_intensity") {
+                if (typeof val !== "string" || !INTENSITY_LEVELS.includes(val))
+                    throw new Error("invalid default intensity");
+                config.default_intensity = val;
+                config.selected_intensity = val;
+            }
+            else if (key === "model_context_window") {
+                if (!isContextWindow(val))
+                    throw new Error("invalid model context window");
+            }
+            else if (key === "approval_model") {
+                if (typeof val !== "string" || (val && !loadModels().providers.some((p) => p.models.some((m) => m.name === val))))
+                    throw new Error("unknown approval model");
+                config[key] = val;
+            }
+            else if (key === "sound_alerts") {
+                if (typeof val !== "boolean")
+                    throw new Error("sound alerts must be a boolean");
+                config[key] = val;
+            }
+            else if (key === "auto_approve_extreme_risk") {
+                if (typeof val !== "boolean")
+                    throw new Error("auto-approval must be a boolean");
+                config[key] = val;
+            }
+            else if (key === "web_password") {
+                validateWebPassword(val);
+            }
+            else {
+                throw new Error("unknown settings field");
+            }
+        }
+    }
+    if (body.selection !== undefined) {
+        const chosen = resolveModelSelection(body.selection, false);
+        config.selected_provider = chosen.provider;
+        config.selected_model = chosen.model.name;
+        config.selected_model_url = chosen.model.url;
+        config.selected_model_api_key = chosen.model.api_key;
+        config.selected_model_streaming = chosen.model.supports_streaming;
+        config.selected_intensity = chosen.intensity;
+        config.default_intensity = chosen.intensity;
+    }
+    const password = body.settings?.web_password;
+    if (password !== undefined)
+        config.web_password_hash = hashWebPassword(password);
+    const window = body.settings?.model_context_window;
+    if (window !== undefined) {
+        const selection = body.selection ?? getWebSettings().selection;
+        const chosen = resolveModelSelection(selection, false);
+        const models = loadModels();
+        const model = models.providers.find((p) => p.name === chosen.provider).models.find((m) => m.name === chosen.model.name);
+        model.context_window = window;
+        saveModels(models);
+    }
+    saveConfig(config);
+}

package/dist/width.js

@@ -424,3 +424,23 @@ export function ellipsize(text, width) {
         return "…";
     return truncateByWidth(text, width - 1) + "…";
 }
+/** Trim the beginning of `text`, keeping the end (useful for long paths). */
+export function ellipsizeStart(text, width) {
+    if (width <= 0)
+        return "";
+    if (displayWidth(text) <= width)
+        return text;
+    if (width === 1)
+        return "…";
+    const chars = Array.from(text);
+    let out = "";
+    let used = 0;
+    for (let i = chars.length - 1; i >= 0; i--) {
+        const cw = wcwidth(chars[i].codePointAt(0) ?? 0);
+        if (used + cw > width - 1)
+            break;
+        out = chars[i] + out;
+        used += cw;
+    }
+    return "…" + out;
+}