neoctl 0.2.38 → 0.2.40

package/dist/web/index.js

@@ -5,6 +5,7 @@ import http from "node:http";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
+import { dockerEnabled } from "../execution/docker.js";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { readSessionPrompt, updateSessionPrompt, SessionPromptError } from "./session-prompt-protocol.js";
@@ -104,7 +105,7 @@ const DEFAULT_WEB_RUNTIME_KEY = "__default__";
 export async function runWebServer(argv = process.argv.slice(2), runtimeOptions = {}) {
     const options = parseWebArgs(argv);
     const router = await createWebRuntimeRouter(runtimeOptions);
-    const server = http.createServer((req, res) => void route(req, res, router));
+    const server = http.createServer((req, res) => void handleWebRequest(req, res, router));
     await new Promise((resolve) => server.listen(options.port, options.host, resolve));
     const address = server.address();
     const actualPort = typeof address === "object" && address ? address.port : options.port;
@@ -194,6 +195,14 @@ export async function createWebRuntime(options = {}) {
         modelGateway,
         tools,
         contextManagerFactory: (cwd) => new DefaultContextManager({ cwd }),
+        refreshTools: () => {
+            if (!options.resolveGlobalToolOverrides)
+                return;
+            if (runtime)
+                refreshGlobalToolOverrides(runtime);
+            else
+                applyToolOverrides(tools, toolCatalog, normalizeToolOverrides(options.resolveGlobalToolOverrides(), toolCatalog), sessionToolOverrides);
+        },
         additionalPromptSections: [
             ...(options.externalPromptSections ?? []),
             ...activePlugins.flatMap((plugin) => plugin.promptSections ?? []),
@@ -207,7 +216,7 @@ export async function createWebRuntime(options = {}) {
         session: {
             enabled: process.env.AGENT_SESSION_TRANSCRIPT !== "0",
             sessionId: options.sessionId ?? process.env.AGENT_SESSION_ID,
-            rootDir: process.env.AGENT_SESSION_DIR,
+            rootDir: options.sessionRootDir ?? process.env.AGENT_SESSION_DIR,
             resume: options.resume ?? parseResumeFlag(process.env.AGENT_SESSION_RESUME),
             toolResultThresholdChars: process.env.AGENT_TOOL_RESULT_THRESHOLD_CHARS ? Number(process.env.AGENT_TOOL_RESULT_THRESHOLD_CHARS) : undefined,
         },
@@ -242,6 +251,7 @@ export async function createWebRuntime(options = {}) {
             globalOverrides: globalToolOverrides,
             sessionOverrides: sessionToolOverrides,
             persistGlobal: options.persistGlobalToolOverrides,
+            resolveGlobal: options.resolveGlobalToolOverrides,
             persistSession: options.persistSessionToolOverrides,
             resolveSession: options.resolveSessionToolOverrides,
         },
@@ -279,6 +289,14 @@ function applyToolOverrides(registry, catalog, globalOverrides, sessionOverrides
     for (const tool of catalog)
         registry.setEnabled(tool.name, sessionOverrides[tool.name] ?? globalOverrides[tool.name] ?? true);
 }
+/** Called only at a safe turn boundary or while idle, never during tool execution. */
+export function refreshGlobalToolOverrides(runtime) {
+    const support = runtime.toolSupport;
+    if (!support?.resolveGlobal)
+        return;
+    support.globalOverrides = normalizeToolOverrides(support.resolveGlobal(), support.catalog);
+    applyToolOverrides(runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+}
 /** Bind only the foreground view; never stop work owned by another session. */
 export function activateSession(runtime) {
     const sessionDir = runtime.engine.snapshot().session?.sessionDir || undefined;
@@ -367,6 +385,14 @@ export class WebRuntimeRouter {
     async snapshot(scope = {}, includeCatalog = true) {
         return (await this.get(scope)).snapshot(includeCatalog);
     }
+    async reloadModelConfig() {
+        const repls = await Promise.all([...this.repls.values()]);
+        await Promise.all(repls.map(repl => repl.reloadModelConfig()));
+    }
+    async reloadGlobalTools(overrides) {
+        const repls = await Promise.all([...this.repls.values()]);
+        await Promise.all(repls.map(repl => repl.reloadGlobalTools(overrides)));
+    }
     activeScopes() {
         return [...this.repls.keys()];
     }
@@ -427,6 +453,8 @@ export class WebRepl {
     queuedAttachments;
     foregroundRun;
     foregroundRunToken = 0;
+    stoppingRun;
+    immediateSend;
     pendingUserImageEchoIds;
     pendingUserImageEchoMessageId;
     runtimeContextRevision = 0;
@@ -561,6 +589,7 @@ export class WebRepl {
         };
     }
     globalTools() {
+        this.runtime.engine.refreshToolsIfIdle();
         const support = this.runtime.toolSupport;
         if (!support)
             return { items: [] };
@@ -572,6 +601,7 @@ export class WebRepl {
         };
     }
     sessionTools() {
+        this.runtime.engine.refreshToolsIfIdle();
         const support = this.runtime.toolSupport;
         const sessionId = this.runtime.engine.snapshot().session?.sessionId;
         if (!support)
@@ -608,18 +638,25 @@ export class WebRepl {
         if (!normalized.ok)
             return normalized;
         try {
-            support.globalOverrides = normalized.value;
-            this.syncPluginToolRegistration();
-            applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+            // Persist before publishing so a failed write never changes active capabilities.
             if (support.persistGlobal)
-                await support.persistGlobal(support.globalOverrides);
-            await this.refreshToolConfiguration();
+                await support.persistGlobal(normalized.value);
+            await this.reloadGlobalTools(normalized.value);
             return { ok: true, state: this.globalTools() };
         }
         catch (error) {
             return actionFailure("TOOL_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
         }
     }
+    async reloadGlobalTools(overrides) {
+        const support = this.runtime.toolSupport;
+        if (!support)
+            return;
+        support.globalOverrides = normalizeToolOverrides(overrides, support.catalog);
+        this.syncPluginToolRegistration();
+        applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+        await this.refreshToolConfiguration();
+    }
     async setSessionTools(value) {
         if (this.busy)
             return actionFailure("TOOL_UPDATE_BLOCKED", "cannot change session tools while a response is running");
@@ -710,12 +747,14 @@ export class WebRepl {
         const support = this.runtime.toolSupport;
         if (!support)
             return;
-        support.sessionOverrides = normalizeToolOverrides(overrides, support.catalog);
-        this.syncPluginToolRegistration();
-        applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+        const normalized = normalizeToolOverrides(overrides, support.catalog);
         const sessionId = this.runtime.engine.snapshot().session?.sessionId;
         if (persist && sessionId && support.persistSession)
-            await support.persistSession(sessionId, support.sessionOverrides);
+            await support.persistSession(sessionId, normalized);
+        support.sessionOverrides = normalized;
+        this.runtime.engine.refreshToolsIfIdle();
+        this.syncPluginToolRegistration();
+        applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
         await this.refreshToolConfiguration();
     }
     syncPluginToolRegistration() {
@@ -764,6 +803,8 @@ export class WebRepl {
         this.publishRuntimeContext();
     }
     async submit(text, attachments = []) {
+        if (this.stoppingRun || this.immediateSend)
+            return { ok: false, error: "正在停止上一轮请求，请稍后发送" };
         const trimmed = text.trim();
         if (!trimmed && attachments.length === 0)
             return { ok: true };
@@ -783,7 +824,11 @@ export class WebRepl {
         this.startRun(text, attachments);
         return { ok: true };
     }
-    submitImmediately(text, attachments = []) {
+    async submitImmediately(text, attachments = []) {
+        if (this.immediateSend)
+            return { ok: false, error: "正在发送，请勿重复提交" };
+        if (this.stoppingRun)
+            return { ok: false, error: "正在停止上一轮请求，请稍后发送" };
         if (!this.busy) {
             this.startRun(text, attachments);
             return { ok: true, interrupted: false };
@@ -792,15 +837,21 @@ export class WebRepl {
         return this.sendQueuedNow();
     }
     sendQueuedNow() {
+        if (this.immediateSend)
+            return this.immediateSend;
         const queuedText = this.queuedInput;
         const queuedAttachments = this.queuedAttachments ?? [];
         if (queuedText === undefined)
-            return { ok: true, interrupted: false };
-        this.queuedInput = undefined;
-        this.queuedAttachments = undefined;
-        const interrupted = this.stopForegroundRun("Interrupted to send queued web input");
-        this.startRun(queuedText, queuedAttachments);
-        return { ok: true, interrupted };
+            return Promise.resolve({ ok: true, interrupted: false });
+        const pending = (async () => {
+            const interrupted = await this.stopForegroundRun("Interrupted to send queued web input", true);
+            this.startRun(queuedText, queuedAttachments);
+            return { ok: true, interrupted };
+        })();
+        this.immediateSend = pending;
+        void pending.finally(() => { if (this.immediateSend === pending)
+            this.immediateSend = undefined; }).catch(() => undefined);
+        return pending;
     }
     enqueueInput(text, attachments) {
         this.queuedInput = mergeWebQueuedInput(this.queuedInput, text);
@@ -916,12 +967,13 @@ export class WebRepl {
                     source: payload.source,
                 });
             const usage = payload.usage?.trim();
-            if (!shouldClear && usage) {
+            if (!shouldClear) {
                 this.append({
                     kind: "meta",
                     title: "提示词用法",
-                    text: usage,
+                    text: usage || "提示词已应用。请在下方输入框中描述你的需求，按提示词要求补充材料后发送；它会用于后续对话。可在提示词管理中切换或清除。",
                     format: "markdown",
+                    presentationLevel: "primary",
                 });
             }
             this.broadcastSync();
@@ -1066,6 +1118,9 @@ export class WebRepl {
         const provider = parseLoginProvider(providerValue);
         if (!provider)
             return actionFailure("LOGIN_INVALID", "provider must be openai");
+        if (dockerEnabled() && !values.apiKey?.trim()) {
+            values = { ...values, apiKey: parseEnvFileSafe(this.runtime.envPath).OPENAI_API_KEY || process.env.OPENAI_API_KEY || "" };
+        }
         const payload = { ...createLoginFormPayload(this.runtime.envPath, provider), provider, values };
         const validationError = validateLoginFormPayload(payload);
         if (validationError)
@@ -1073,18 +1128,7 @@ export class WebRepl {
         try {
             await saveLoginPayloadToEnv(payload);
             applyLoginPayloadToProcessEnv(payload);
-            const config = readModelProviderConfig(process.env);
-            if (!config)
-                throw new Error("Saved provider config could not be loaded from environment.");
-            const innerGateway = createModelGatewayFromConfig(config);
-            this.runtime.modelGateway.setInner(innerGateway);
-            this.runtime.agentRuntime.modelGateway = this.runtime.modelGateway;
-            this.runtime.engine.setModelProvider({ modelGateway: this.runtime.modelGateway, model: config.model, reasoning: config.defaultReasoning });
-            syncImageGenerationTool(this.runtime, config.provider);
-            this.runtime.defaultReasoning = config.defaultReasoning;
-            const metrics = await this.runtime.engine.contextMetrics();
-            this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
-            this.publishRuntimeContext();
+            await this.reloadModelConfig();
             return { ok: true };
         }
         catch (error) {
@@ -1092,8 +1136,27 @@ export class WebRepl {
             return actionFailure("LOGIN_SAVE_FAILED", message);
         }
     }
-    interrupt() {
-        const interrupted = this.stopForegroundRun("Interrupted from neo web");
+    async reloadModelConfig() {
+        const config = readModelProviderConfig(process.env);
+        if (!config)
+            throw new Error("Saved provider config could not be loaded from environment.");
+        const innerGateway = createModelGatewayFromConfig(config);
+        this.runtime.modelGateway.setInner(innerGateway);
+        this.runtime.agentRuntime.modelGateway = this.runtime.modelGateway;
+        this.runtime.engine.setModelProvider({ modelGateway: this.runtime.modelGateway, model: config.model, reasoning: config.defaultReasoning });
+        for (const run of this.backgroundSessionRuns.values()) {
+            run.engine.setModelProvider({ modelGateway: this.runtime.modelGateway, model: config.model, reasoning: config.defaultReasoning });
+        }
+        syncImageGenerationTool(this.runtime, config.provider);
+        this.runtime.defaultReasoning = config.defaultReasoning;
+        const metrics = await this.runtime.engine.contextMetrics();
+        this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
+        this.publishRuntimeContext();
+    }
+    async interrupt() {
+        if (this.immediateSend)
+            await this.immediateSend;
+        const interrupted = await this.stopForegroundRun("Interrupted from neo web");
         return { ok: true, interrupted };
     }
     cancelQueue() {
@@ -1146,15 +1209,15 @@ export class WebRepl {
         this.assistantLineId = undefined;
         this.finalizedThinkingLineId = undefined;
     }
-    stopForegroundRun(reason) {
+    stopForegroundRun(reason, keepBusy = false) {
+        if (this.stoppingRun)
+            return this.stoppingRun;
         const controller = this.activeAbortController;
+        const run = this.foregroundRun;
         const runWasActive = this.busy || Boolean(controller && !controller.signal.aborted);
         this.foregroundRunToken += 1;
-        this.foregroundRun = undefined;
-        this.runtime.usage.reset();
         if (controller && !controller.signal.aborted)
             controller.abort(reason);
-        this.activeAbortController = undefined;
         this.interruptArmed = false;
         this.queuedInput = undefined;
         this.queuedAttachments = undefined;
@@ -1162,10 +1225,26 @@ export class WebRepl {
         this.pendingUserImageEchoMessageId = undefined;
         this.finalizeForegroundView();
         this.cancelLiveToolLines(reason);
-        this.busy = false;
-        this.status = { ...this.status, phase: "ready", detail: undefined, currentTool: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined };
+        this.busy = true;
+        this.status = { ...this.status, phase: "running", detail: "stopping", currentTool: undefined, retryCooldownUntil: undefined };
         this.broadcastSync();
-        return runWasActive;
+        const pending = (async () => {
+            // Abort is cooperative: the engine still owns its run until the iterator settles.
+            await run;
+            if (this.foregroundRun === run)
+                this.foregroundRun = undefined;
+            if (this.activeAbortController === controller)
+                this.activeAbortController = undefined;
+            this.runtime.usage.reset();
+            this.busy = keepBusy;
+            this.status = { ...this.status, phase: keepBusy ? "running" : "ready", detail: undefined, currentTool: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined };
+            this.broadcastSync();
+            return runWasActive;
+        })();
+        this.stoppingRun = pending;
+        void pending.finally(() => { if (this.stoppingRun === pending)
+            this.stoppingRun = undefined; }).catch(() => undefined);
+        return pending;
     }
     agentTaskSnapshot(task) {
         const terminal = this.runtime.taskStore.isTerminal(task);
@@ -1993,7 +2072,8 @@ function reqKeepAlive(res) {
     timer.unref?.();
     res.on("close", () => clearInterval(timer));
 }
-async function route(req, res, router) {
+/** Embed runtime HTTP routes behind an application's own authentication/authorization layer. */
+export async function handleWebRequest(req, res, router) {
     const url = new URL(req.url ?? "/", "http://localhost");
     try {
         if (req.method === "GET" && url.pathname === "/")
@@ -2146,14 +2226,14 @@ async function route(req, res, router) {
         }
         if (req.method === "POST" && url.pathname === "/api/submit-now") {
             const body = await readJsonBody(req);
-            return sendJson(res, repl.submitImmediately(String(body.text ?? ""), sanitizeWebAttachments(body.attachments)));
+            return sendJson(res, await repl.submitImmediately(String(body.text ?? ""), sanitizeWebAttachments(body.attachments)));
         }
         if (req.method === "POST" && url.pathname === "/api/interrupt")
-            return sendJson(res, repl.interrupt());
+            return sendJson(res, await repl.interrupt());
         if (req.method === "POST" && url.pathname === "/api/queue/cancel")
             return sendJson(res, repl.cancelQueue());
         if (req.method === "POST" && url.pathname === "/api/queue/send-now")
-            return sendJson(res, repl.sendQueuedNow());
+            return sendJson(res, await repl.sendQueuedNow());
         if (req.method === "GET" && url.pathname === "/api/sessions")
             return sendJson(res, await repl.listSessions());
         if (req.method === "POST" && url.pathname === "/api/sessions/resume") {
@@ -2631,7 +2711,7 @@ function createLoginFormPayload(envPath, provider) {
 function loginValuesForProvider(provider, env) {
     const values = {};
     for (const field of LOGIN_FIELD_DEFINITIONS[provider])
-        values[field.key] = env[field.envKey] ?? "";
+        values[field.key] = dockerEnabled() && field.secret ? "" : env[field.envKey] ?? "";
     if (!values.baseUrl)
         values.baseUrl = defaultBaseUrlForLoginProvider(provider);
     if (!values.model)