neoctl 0.1.7 → 0.1.9

package/dist/web/index.js

@@ -197,6 +197,9 @@ class WebRepl {
     status;
     busy = false;
     queuedInput;
+    foregroundRun;
+    backgroundSessionRuns = new Map();
+    suppressReattachedStreaming = new Set();
     backgroundTaskCount;
     constructor(runtime) {
         this.runtime = runtime;
@@ -228,6 +231,9 @@ class WebRepl {
             busy: this.busy,
             queuedInput: this.queuedInput,
             backgroundTaskCount: this.backgroundTaskCount,
+            backgroundTasks: this.backgroundTasks(),
+            backgroundSessionRunCount: this.backgroundSessionRuns.size,
+            runningSessionIds: [...this.backgroundSessionRuns.keys()],
             session: this.runtime.engine.snapshot().session,
             catalog: includeCatalog ? webCatalog(this.runtime) : undefined,
             interactive: includeCatalog ? webInteractiveCatalog(this.runtime) : undefined,
@@ -239,39 +245,65 @@ class WebRepl {
         const trimmed = text.trim();
         if (!trimmed && attachments.length === 0)
             return { ok: true };
-        if (this.busy) {
+        const command = parseReplCommand(text);
+        const startsNewSessionWhileBusy = this.busy && command.type === "new";
+        if (this.busy && !startsNewSessionWhileBusy) {
             if (this.queuedInput !== undefined)
                 return { ok: false, error: "A queued prompt is already waiting. Press Esc/Ctrl+C in the web UI to clear it." };
             this.queuedInput = text;
             this.broadcastSync();
             return { ok: true };
         }
-        void this.handleCommandOrPrompt(text, attachments).catch((error) => {
+        const run = this.handleCommandOrPrompt(text, attachments).catch((error) => {
             this.append({ kind: "error", text: error instanceof Error ? error.message : String(error) });
             this.setBusy(false);
             this.setStatus({ ...this.status, phase: "ready", detail: undefined });
         });
+        this.foregroundRun = run;
+        run.finally(() => {
+            if (this.foregroundRun === run)
+                this.foregroundRun = undefined;
+        }).catch(() => undefined);
         return { ok: true };
     }
     async listSessions() {
-        return this.runtime.engine.listSessions(Number.POSITIVE_INFINITY);
+        const sessions = await this.runtime.engine.listSessions(Number.POSITIVE_INFINITY);
+        const runningSessionIds = [...this.backgroundSessionRuns.keys()];
+        return { sessions, runningSessionIds };
     }
     async resumeSession(sessionId) {
         if (!sessionId)
             return { ok: false, error: "sessionId is required" };
         try {
-            const snapshot = await this.runtime.engine.resumeSession(sessionId);
-            const metrics = await this.runtime.engine.contextMetrics();
-            this.runtime.usage.reset();
-            this.status = initialStatus(this.runtime, metrics);
-            const lineId = { current: 0 };
-            this.lines = initialLines(this.runtime, lineId);
-            this.lineId = lineId.current;
-            this.assistantLineId = undefined;
-            this.thinkingLineId = undefined;
-            this.finalizedThinkingLineId = undefined;
-            this.toolLineIds.clear();
-            this.append(systemLine(formatResume(snapshot)));
+            const running = this.backgroundSessionRuns.get(sessionId);
+            if (running) {
+                await this.reattachRunningSession(running);
+                return { ok: true };
+            }
+            await this.detachRunningForeground("session switch");
+            this.runtime.engine = this.runtime.engine.forkForSession(sessionId, true);
+            await this.runtime.engine.initialize();
+            const snapshot = this.runtime.engine.snapshot().session;
+            if (!snapshot)
+                throw new Error("session transcripts are disabled");
+            await this.refreshSessionView(systemLine(formatResume(snapshot)));
+            return { ok: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.append({ kind: "error", text: message });
+            return { ok: false, error: message };
+        }
+    }
+    async newSession() {
+        try {
+            await this.detachRunningForeground("new session");
+            this.runtime.engine = this.runtime.engine.forkForSession(undefined, false);
+            await this.runtime.engine.initialize();
+            const snapshot = this.runtime.engine.snapshot().session;
+            if (!snapshot)
+                throw new Error("session transcripts are disabled");
+            await this.refreshSessionView(systemLine(`new session ${snapshot.sessionId}`));
             return { ok: true };
         }
         catch (error) {
@@ -280,6 +312,21 @@ class WebRepl {
             return { ok: false, error: message };
         }
     }
+    async refreshSessionView(line) {
+        const metrics = await this.runtime.engine.contextMetrics();
+        this.runtime.usage.reset();
+        this.status = initialStatus(this.runtime, metrics);
+        const lineId = { current: 0 };
+        this.lines = initialLines(this.runtime, lineId);
+        this.lineId = lineId.current;
+        this.assistantLineId = undefined;
+        this.thinkingLineId = undefined;
+        this.finalizedThinkingLineId = undefined;
+        this.toolLineIds.clear();
+        if (line)
+            this.append(line);
+        this.broadcastSync();
+    }
     async deleteSession(sessionId) {
         if (!sessionId)
             return { ok: false, error: "sessionId is required" };
@@ -370,6 +417,61 @@ class WebRepl {
         this.status = next;
         this.broadcastSync();
     }
+    backgroundTasks() {
+        return this.runtime.taskStore.list()
+            .filter((task) => !this.runtime.taskStore.isTerminal(task))
+            .map((task) => ({
+            taskId: task.taskId,
+            agentId: task.agentId,
+            type: task.type,
+            status: task.status,
+            description: task.description,
+            createdAt: task.createdAt,
+        }));
+    }
+    async detachRunningForeground(reason) {
+        if (!this.busy)
+            return false;
+        const snapshot = this.runtime.engine.snapshot().session;
+        const sessionId = snapshot?.sessionId ?? `session-${Date.now().toString(36)}`;
+        const run = this.foregroundRun;
+        if (run && !this.backgroundSessionRuns.has(sessionId)) {
+            const backgroundRun = {
+                sessionId,
+                title: snapshot?.title,
+                reason,
+                startedAt: Date.now(),
+                engine: this.runtime.engine,
+                abortController: this.activeAbortController ?? new AbortController(),
+                promise: run,
+            };
+            this.backgroundSessionRuns.set(sessionId, backgroundRun);
+            run.finally(() => {
+                this.backgroundSessionRuns.delete(sessionId);
+                this.suppressReattachedStreaming.delete(backgroundRun.engine);
+                this.broadcastSync();
+            }).catch(() => undefined);
+        }
+        this.activeAbortController = undefined;
+        this.interruptArmed = false;
+        this.queuedInput = undefined;
+        this.busy = false;
+        this.status = { ...this.status, phase: "ready", detail: undefined };
+        this.append(systemLine(`Detached running ${sessionId} to background for ${reason}.`));
+        return true;
+    }
+    async reattachRunningSession(run) {
+        await this.detachRunningForeground("session switch");
+        this.backgroundSessionRuns.delete(run.sessionId);
+        this.runtime.engine = run.engine;
+        this.activeAbortController = run.abortController;
+        this.interruptArmed = false;
+        this.foregroundRun = run.promise;
+        this.suppressReattachedStreaming.add(run.engine);
+        await this.refreshSessionView(systemLine(`reattached running session ${run.sessionId}`));
+        this.setBusy(true);
+        this.setStatus({ ...this.status, phase: "running", detail: "working" });
+    }
     reduce(event) {
         this.status = reduceStatus(this.status, event);
         if (event.type === "usage")
@@ -496,12 +598,17 @@ class WebRepl {
         if (command.type === "reset") {
             this.runtime.engine.reset();
             this.runtime.usage.reset();
-            this.status = resetStatus(this.runtime);
+            this.status = await resetStatus(this.runtime);
             this.append(systemLine("transcript reset"));
             return;
         }
         if (command.type === "state") {
-            this.append(systemLine(formatReplData({ ...this.runtime.engine.snapshot(), communicationLog: this.runtime.communicationLogger.snapshot() }, 12000), EXPANDED_SUMMARY_MAX_LINES));
+            const contextMetrics = await this.runtime.engine.contextMetrics();
+            this.append(systemLine(formatReplData({ ...this.runtime.engine.snapshot(), contextMetrics, communicationLog: this.runtime.communicationLogger.snapshot() }, 12000), EXPANDED_SUMMARY_MAX_LINES));
+            return;
+        }
+        if (command.type === "new") {
+            await this.newSession();
             return;
         }
         if (command.type === "sessions") {
@@ -576,20 +683,35 @@ class WebRepl {
         this.interruptArmed = false;
         this.setBusy(true);
         this.setStatus({ ...this.status, phase: "running", detail: "working", usage: undefined, streamedOutputTokens: 0, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined });
+        const engine = this.runtime.engine;
         try {
-            for await (const event of this.runtime.engine.sendUserText(promptPayload.text, { abortSignal: abortController.signal, blocks: promptPayload.blocks, displayText: promptPayload.displayText })) {
+            for await (const event of engine.sendUserText(promptPayload.text, { abortSignal: abortController.signal, blocks: promptPayload.blocks, displayText: promptPayload.displayText })) {
+                if (this.runtime.engine !== engine)
+                    continue;
+                if (this.suppressReattachedStreaming.has(engine)) {
+                    if (event.type === "message" || event.type === "terminal" || event.type === "error" || event.type === "context.metrics" || event.type === "usage") {
+                        if (event.type === "message" || event.type === "terminal" || event.type === "error")
+                            this.suppressReattachedStreaming.delete(engine);
+                        this.handleEvent(event);
+                    }
+                    continue;
+                }
                 this.handleEvent(event);
             }
         }
         catch (error) {
-            this.finalizeLiveLine(this.assistantLineId);
-            this.finalizeThinkingLine();
-            this.finalizeActiveToolLines();
-            this.assistantLineId = undefined;
-            this.finalizedThinkingLineId = undefined;
-            this.append({ kind: "error", text: error instanceof Error ? error.message : String(error) });
+            if (this.runtime.engine === engine) {
+                this.finalizeLiveLine(this.assistantLineId);
+                this.finalizeThinkingLine();
+                this.finalizeActiveToolLines();
+                this.assistantLineId = undefined;
+                this.finalizedThinkingLineId = undefined;
+                this.append({ kind: "error", text: error instanceof Error ? error.message : String(error) });
+            }
         }
         finally {
+            if (this.runtime.engine !== engine)
+                return;
             if (this.activeAbortController === abortController)
                 this.activeAbortController = undefined;
             this.interruptArmed = false;
@@ -673,11 +795,13 @@ async function route(req, res, repl) {
         if (req.method === "POST" && url.pathname === "/api/interrupt")
             return sendJson(res, repl.interrupt());
         if (req.method === "GET" && url.pathname === "/api/sessions")
-            return sendJson(res, { sessions: await repl.listSessions() });
+            return sendJson(res, await repl.listSessions());
         if (req.method === "POST" && url.pathname === "/api/sessions/resume") {
             const body = await readJsonBody(req);
             return sendJson(res, await repl.resumeSession(String(body.sessionId ?? "")));
         }
+        if (req.method === "POST" && url.pathname === "/api/sessions/new")
+            return sendJson(res, await repl.newSession());
         if (req.method === "POST" && url.pathname === "/api/sessions/delete") {
             const body = await readJsonBody(req);
             return sendJson(res, await repl.deleteSession(String(body.sessionId ?? "")));
@@ -765,8 +889,8 @@ function restoredHistoryLines(runtime) {
 function initialStatus(runtime, metrics = runtime.initialMetrics) {
     return { phase: "ready", metrics: { ...metrics, messageCount: runtime.engine.snapshot().messages }, streamedOutputTokens: 0, activityTick: 0 };
 }
-function resetStatus(runtime) {
-    return initialStatus(runtime, initialContextMetrics(runtime.engine.getModelSettings().model, runtime.engine.snapshot().messages, runtime.initialMetrics.toolCount));
+async function resetStatus(runtime) {
+    return initialStatus(runtime, await runtime.engine.contextMetrics());
 }
 function buildWebPromptPayload(displayText, attachments) {
     const activeAttachments = attachments.filter((attachment) => displayText.includes(attachment.label));
@@ -1339,26 +1463,190 @@ function formatPlanToolPayload(payload) {
     return sections.filter(Boolean).join("\n");
 }
 function formatToolResult(toolName, output, ok) {
-    if (isExecOutput(output)) {
-        const status = output.timedOut ? "timed out" : output.exitCode === 0 ? "exit 0" : `exit ${output.exitCode ?? output.signal ?? "unknown"}`;
-        const sections = [`${status} · ${output.durationMs}ms`, `$ ${output.command}`];
-        if (output.stdout)
-            sections.push("stdout:", output.stdout.replace(/\s+$/u, ""));
-        if (output.stderr)
-            sections.push("stderr:", output.stderr.replace(/\s+$/u, ""));
-        if (!output.stdout && !output.stderr)
-            sections.push(ok ? "no output" : "no captured output");
-        return { text: sections.join("\n"), format: "ansi" };
-    }
+    if ((toolName === "edit" || toolName === "write") && isRecord(output) && isEditToolOutput(output))
+        return { text: formatEditToolDiff(output, ok), format: "diff", summaryMaxLines: EDIT_TOOL_SUMMARY_MAX_LINES };
+    if (isExecOutput(output))
+        return { text: formatExecToolResult(output, ok), format: "plain", summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
+    if (toolName === "list" && isRecord(output))
+        return { text: formatListToolResult(output, ok) };
+    if (toolName === "read" && isRecord(output))
+        return { text: formatReadToolResult(output, ok) };
+    if (toolName === "grep" && isRecord(output))
+        return { text: formatGrepToolResult(output, ok) };
+    if (toolName === "search" && isRecord(output))
+        return { text: formatWebSearchToolResult(output, ok), summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
     if (toolName === "plan" && isPlanToolPayload(output))
         return { text: formatPlanToolPayload(output), full: true, bodyTitle: planToolBodyTitle(output) };
     if (typeof output === "string")
         return { text: output, format: hasAnsi(output) ? "ansi" : undefined, summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
     return { text: `${ok ? "ok" : "failed"}\n${formatReplData(output, 6000)}`, summaryMaxLines: EXPANDED_SUMMARY_MAX_LINES };
 }
+function isEditToolOutput(value) {
+    return typeof value.path === "string" && typeof value.operation === "string" && typeof value.replacements === "number" && Array.isArray(value.patch) && value.patch.every(isEditPatchHunk);
+}
+function isEditPatchHunk(value) {
+    return isRecord(value) && typeof value.oldStart === "number" && typeof value.oldLines === "number" && typeof value.newStart === "number" && typeof value.newLines === "number" && Array.isArray(value.lines) && value.lines.every((line) => typeof line === "string");
+}
+function formatEditToolDiff(output, ok) {
+    const lines = [
+        `${ok ? output.operation : "failed"} ${output.path}, ${output.replacements} replacement(s)`,
+        `--- ${output.path}`,
+        `+++ ${output.path}`,
+    ];
+    for (const hunk of output.patch) {
+        lines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+        lines.push(...formatEditPatchHunkLines(hunk));
+    }
+    if (output.patch.length === 0)
+        lines.push("no changes");
+    return lines.join("\n");
+}
+function formatEditPatchHunkLines(hunk) {
+    const oldLineWidth = diffLineNumberWidth(hunk.oldStart, hunk.oldLines);
+    const newLineWidth = diffLineNumberWidth(hunk.newStart, hunk.newLines);
+    let oldLineNumber = hunk.oldStart;
+    let newLineNumber = hunk.newStart;
+    return hunk.lines.map((rawLine) => {
+        const marker = diffLineMarker(rawLine);
+        if (!marker)
+            return rawLine;
+        const showOldLineNumber = marker !== "+";
+        const showNewLineNumber = marker !== "-";
+        const oldLineLabel = showOldLineNumber ? String(oldLineNumber).padStart(oldLineWidth) : " ".repeat(oldLineWidth);
+        const newLineLabel = showNewLineNumber ? String(newLineNumber).padStart(newLineWidth) : " ".repeat(newLineWidth);
+        if (showOldLineNumber)
+            oldLineNumber += 1;
+        if (showNewLineNumber)
+            newLineNumber += 1;
+        return `${oldLineLabel} ${newLineLabel} │ ${marker}${rawLine.slice(1)}`;
+    });
+}
+function diffLineNumberWidth(start, lineCount) {
+    const end = lineCount > 0 ? start + lineCount - 1 : start;
+    return Math.max(String(start).length, String(end).length, 2);
+}
+function diffLineMarker(line) {
+    const marker = line[0];
+    return marker === "+" || marker === "-" || marker === " " ? marker : undefined;
+}
 function isExecOutput(value) {
     return isRecord(value) && typeof value.command === "string" && typeof value.durationMs === "number";
 }
+function formatExecToolResult(output, ok) {
+    const status = output.timedOut ? "timed out" : output.exitCode === 0 ? "exit 0" : `exit ${output.exitCode ?? output.signal ?? "unknown"}`;
+    const lines = ["exec result", `status: ${status}`, `duration: ${output.durationMs}ms`, `command: ${output.command}`];
+    const stdout = typeof output.stdout === "string" ? output.stdout.replace(/\s+$/u, "") : "";
+    const stderr = typeof output.stderr === "string" ? output.stderr.replace(/\s+$/u, "") : "";
+    if (stdout)
+        lines.push("stdout:", stdout);
+    if (stderr)
+        lines.push("stderr:", stderr);
+    if (!stdout && !stderr)
+        lines.push(ok ? "output: (none)" : "output: (not captured)");
+    return lines.join("\n");
+}
+function formatListToolResult(output, ok) {
+    const pathValue = typeof output.path === "string" ? output.path : "";
+    const typeValue = typeof output.type === "string" ? output.type : "result";
+    const returnedEntries = typeof output.returnedEntries === "number" ? output.returnedEntries : undefined;
+    const totalFiles = typeof output.totalFiles === "number" ? output.totalFiles : undefined;
+    const totalDirectories = typeof output.totalDirectories === "number" ? output.totalDirectories : undefined;
+    const entries = Array.isArray(output.entries) ? output.entries : [];
+    const names = entries.map((entry) => (isRecord(entry) && typeof entry.name === "string" ? entry.name : undefined)).filter((name) => Boolean(name)).slice(0, 5);
+    const lines = [ok ? "list result" : "failed"];
+    if (pathValue)
+        lines.push(`path: ${pathValue}`);
+    lines.push(`type: ${typeValue}`);
+    const counts = [returnedEntries !== undefined ? `${returnedEntries} shown` : undefined, totalFiles !== undefined ? `${totalFiles} files` : undefined, totalDirectories !== undefined ? `${totalDirectories} dirs` : undefined].filter((value) => Boolean(value));
+    if (counts.length > 0)
+        lines.push(`entries: ${counts.join(" · ")}`);
+    if (names.length > 0)
+        lines.push("sample:", ...names.map((name) => `  ${name}`));
+    return lines.join("\n");
+}
+function formatReadToolResult(output, ok) {
+    const error = typeof output.error === "string" ? output.error : undefined;
+    if (!ok || error)
+        return ["failed", error ?? formatReplData(output, 1200)].join("\n");
+    const pathValue = typeof output.path === "string" ? output.path : undefined;
+    const startLine = typeof output.startLine === "number" ? output.startLine : undefined;
+    const endLine = typeof output.endLine === "number" ? output.endLine : undefined;
+    const totalLines = typeof output.totalLines === "number" ? output.totalLines : undefined;
+    const hasMoreBefore = output.hasMoreBefore === true;
+    const hasMoreAfter = output.hasMoreAfter === true;
+    const content = typeof output.content === "string" ? output.content.trimEnd() : "";
+    const lines = ["read result"];
+    if (pathValue)
+        lines.push(`file: ${pathValue}`);
+    if (startLine !== undefined && endLine !== undefined && totalLines !== undefined) {
+        const more = [hasMoreBefore ? "more before" : undefined, hasMoreAfter ? "more after" : undefined].filter((value) => Boolean(value)).join(", ");
+        lines.push(`range: lines ${startLine}-${endLine} of ${totalLines}${more ? ` (${more})` : ""}`);
+    }
+    lines.push("content:", content || "(empty range)");
+    return lines.join("\n");
+}
+function formatWebSearchToolResult(output, ok) {
+    const error = typeof output.error === "string" ? output.error : undefined;
+    if (!ok || error)
+        return ["failed", error ?? formatReplData(output, 1200)].join("\n");
+    const provider = typeof output.provider === "string" ? output.provider : "unknown";
+    const query = typeof output.query === "string" ? output.query : "";
+    const returnedResults = typeof output.returnedResults === "number" ? output.returnedResults : undefined;
+    const results = Array.isArray(output.results) ? output.results : [];
+    const lines = [`${returnedResults ?? results.length} web result(s) via ${provider}`];
+    if (query)
+        lines.push(`query: ${query}`);
+    if (output.truncated === true)
+        lines.push("truncated");
+    if (results.length === 0)
+        return [...lines, "no results"].join("\n");
+    results.slice(0, 8).forEach((item, index) => {
+        if (!isRecord(item))
+            return;
+        const title = typeof item.title === "string" && item.title.trim() ? item.title.trim() : "Untitled";
+        const url = typeof item.url === "string" ? item.url : "";
+        const published = typeof item.published === "string" ? ` · ${item.published}` : "";
+        lines.push(`[${index + 1}] ${title}${published}`);
+        if (url)
+            lines.push(url);
+        const highlights = Array.isArray(item.highlights) ? item.highlights.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+        const snippet = highlights[0] ?? (typeof item.text === "string" ? item.text : undefined);
+        if (snippet)
+            lines.push(truncate(snippet.replace(/\s+/gu, " "), 400));
+    });
+    return lines.join("\n");
+}
+function formatGrepToolResult(output, ok) {
+    const error = typeof output.error === "string" ? output.error : undefined;
+    if (!ok || error)
+        return ["failed", error ?? formatReplData(output, 1200)].join("\n");
+    const query = typeof output.query === "string" ? output.query : undefined;
+    const grepPath = typeof output.grepPath === "string" ? output.grepPath : typeof output.path === "string" ? output.path : undefined;
+    const returnedMatches = typeof output.returnedMatches === "number" ? output.returnedMatches : undefined;
+    const totalMatchesKnown = typeof output.totalMatchesKnown === "number" ? output.totalMatchesKnown : undefined;
+    const truncated = output.truncated === true;
+    const matches = Array.isArray(output.matches) ? output.matches.filter(isGrepMatchLike) : [];
+    const lines = ["grep result"];
+    if (query !== undefined)
+        lines.push(`query: ${query}`);
+    if (grepPath !== undefined)
+        lines.push(`path: ${grepPath}`);
+    const countParts = [`${returnedMatches ?? matches.length} shown`, totalMatchesKnown !== undefined ? `${totalMatchesKnown} known` : undefined, truncated ? "truncated" : undefined].filter((value) => Boolean(value));
+    lines.push(`matches: ${countParts.join(" · ")}`);
+    if (matches.length === 0)
+        return [...lines, "no matches"].join("\n");
+    lines.push("results:");
+    for (const match of matches)
+        lines.push(formatGrepMatchLine(match));
+    return lines.join("\n");
+}
+function isGrepMatchLike(value) {
+    return isRecord(value) && typeof value.file === "string" && typeof value.line === "number" && typeof value.text === "string" && (value.column === undefined || typeof value.column === "number");
+}
+function formatGrepMatchLine(match) {
+    const column = match.column !== undefined ? `:${match.column}` : "";
+    return `  ${match.file}:${match.line}${column}: ${match.text}`;
+}
 function formatReplData(value, maxLength) {
     return truncate(formatReplValue(value), maxLength);
 }
@@ -1456,6 +1744,7 @@ function formatNumber(value) {
 }
 const THINKING_SUMMARY_MAX_LINES = 1000;
 const EXPANDED_SUMMARY_MAX_LINES = 1000;
+const EDIT_TOOL_SUMMARY_MAX_LINES = EXPANDED_SUMMARY_MAX_LINES;
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
     runWebServer().catch((error) => {
         console.error(error instanceof Error ? error.stack ?? error.message : String(error));