@co0ontty/wand 4.88.0 → 4.89.0-beta.gb602808

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "b1ee94297085a10acc1bd9b7da943e1a12435851",
-  "builtAt": "2026-10-09T07:15:49.297Z",
-  "version": "4.88.0",
-  "channel": "stable"
+  "commit": "b60280807f605ce884aea7ec30f202157dbb3047",
+  "builtAt": "2026-10-09T11:31:46.251Z",
+  "version": "4.89.0-beta.gb602808",
+  "channel": "beta"
 }

package/dist/daemon-maintenance-state.d.ts

@@ -2,5 +2,7 @@
 export interface DaemonMaintenanceStatus {
     pending: boolean;
     phase: "idle" | "waiting" | "updating" | "retrying";
+    /** HTTP view only; lifecycle status has no caller-specific permissions. */
+    canForceUpdate?: boolean;
 }
 export declare function daemonMaintenanceMessage(status: DaemonMaintenanceStatus): string;

package/dist/daemon-maintenance-targets.d.ts

@@ -13,6 +13,7 @@ export declare function persistentDaemonTarget(options: {
     checkpointPath: string;
     snapshot(includeInventory?: boolean): Promise<OwnerSnapshot>;
     shutdown(snapshot: OwnerSnapshot): Promise<boolean | void>;
+    interrupt?(): Promise<void>;
     ensure(): Promise<void>;
     reconnect(): Promise<void>;
 }): DaemonMaintenanceTarget;

package/dist/daemon-maintenance-targets.js

@@ -74,6 +74,16 @@ export function persistentDaemonTarget(options) {
                 unlinkSync(options.checkpointPath);
             return snapshot;
         },
+        async interrupt(expected) {
+            const current = await options.snapshot();
+            if (current.identity !== expected.identity)
+                throw new Error(`${options.name} owner changed`);
+            if (current.running !== 0) {
+                if (!options.interrupt)
+                    throw new Error(`${options.name} cannot interrupt running executions`);
+                await options.interrupt();
+            }
+        },
         async restart(expected) {
             const current = await options.snapshot();
             if (current.identity !== expected.identity || !current.pending || current.running !== 0) {
@@ -120,6 +130,7 @@ export async function createDaemonMaintenanceTargets(configPath, pty, structured
                     pending: shouldUpgradeRenderDaemon(hello.version, version, 0), running: includeInventory ? countRunningDaemonEntries(sessions) : null };
             },
             shutdown: () => render.requestShutdownDrain(),
+            interrupt: () => render.interruptMaintenanceSessions(),
             async ensure() { const client = await createRenderTerminalHost(configPath, { binaryPath: binary ?? undefined }); client.disconnect(); },
             reconnect: () => render.connect(),
         }));
@@ -157,6 +168,16 @@ export async function createDaemonMaintenanceTargets(configPath, pty, structured
                     process.kill(snapshot.pid, "SIGTERM");
                 }
             },
+            async interrupt() {
+                const sessions = await legacy.request("list");
+                const runs = await legacy.request("structuredList");
+                await Promise.all([
+                    ...sessions.filter(session => session.status === "running")
+                        .map(session => legacy.request("kill", { sessionId: session.sessionId, signal: "SIGTERM" })),
+                    ...runs.filter(run => run.status === "running")
+                        .map(run => legacy.request("structuredKill", { runId: run.runId, signal: "SIGTERM" })),
+                ]);
+            },
             async ensure() { const client = await createTerminalHost(configPath); client.disconnect(); },
             reconnect: () => legacy.connect(),
         }));
@@ -175,6 +196,11 @@ export async function createDaemonMaintenanceTargets(configPath, pty, structured
                     running: result ? countRunningDaemonEntries(result.runs) : null };
             },
             async shutdown() { await structured.request("shutdown", { mode: "drain" }); },
+            async interrupt() {
+                const { runs } = await structured.request("list");
+                await Promise.all(runs.filter(run => run.status === "running")
+                    .map(run => structured.request("interrupt", { runId: run.runId, signal: "SIGTERM" })));
+            },
             async ensure() { const client = await startStructuredRenderHost(configPath); client.disconnect(); },
             reconnect: () => structured.connect(),
         }));

package/dist/daemon-maintenance.d.ts

@@ -23,6 +23,8 @@ export interface DaemonMaintenanceTarget {
     inspect(includeInventory?: boolean): Promise<DaemonInspection>;
     /** Must recheck identity and use graceful shutdown, never a force-kill. */
     restart(expected: DaemonInspection): Promise<void>;
+    /** Explicit manual update only: interrupt authenticated live inventory. */
+    interrupt?(expected: DaemonInspection): Promise<void>;
 }
 export interface DaemonMaintenanceOptions {
     targets: DaemonMaintenanceTarget[];
@@ -30,6 +32,8 @@ export interface DaemonMaintenanceOptions {
     /** Includes Core, starting runs, final checkpoints and queued input. */
     busy(): boolean;
     beginCoreDrain(): () => void;
+    stopExecutions?(): void;
+    coreBusy?(): boolean;
     available(): boolean;
     log(error: unknown): void;
     now?: () => number;
@@ -44,10 +48,13 @@ export declare class DaemonMaintenance {
     private stopped;
     private idleSince;
     private failures;
+    private forcing;
     constructor(options: DaemonMaintenanceOptions);
     status(): DaemonMaintenanceStatus;
     start(): void;
     check(): Promise<void>;
     stop(): Promise<void>;
+    /** Never used by polling. The caller must authenticate and confirm interruption. */
+    forceUpdate(): Promise<DaemonMaintenanceStatus>;
     private inspectAndUpdate;
 }

package/dist/daemon-maintenance.js

@@ -61,6 +61,7 @@ export class DaemonMaintenance {
     stopped = false;
     idleSince = null;
     failures = 0;
+    forcing = null;
     constructor(options) {
         this.options = options;
     }
@@ -80,6 +81,8 @@ export class DaemonMaintenance {
     check() {
         if (this.stopped)
             return Promise.resolve();
+        if (this.forcing)
+            return this.forcing.then(() => { }, () => { });
         if (this.flight)
             return this.flight;
         this.flight = this.inspectAndUpdate().catch((error) => {
@@ -99,6 +102,72 @@ export class DaemonMaintenance {
             clearTimeout(this.timer);
         this.timer = null;
         await this.flight;
+        await this.forcing?.catch(() => { });
+    }
+    /** Never used by polling. The caller must authenticate and confirm interruption. */
+    forceUpdate() {
+        if (this.forcing)
+            return this.forcing;
+        const previous = this.flight;
+        this.forcing = (async () => {
+            await previous;
+            const o = this.options;
+            if (this.stopped || !o.available())
+                throw new Error("当前无法更新，请稍后重试。");
+            return o.admission.exclusive(async () => {
+                if (this.stopped || !o.available())
+                    throw new Error("当前无法更新，请稍后重试。");
+                const releaseCore = o.beginCoreDrain();
+                try {
+                    let fresh = await Promise.all(o.targets.map(target => target.inspect()));
+                    if (!fresh.some(snapshot => snapshot.pending)) {
+                        this.state = { pending: false, phase: "idle" };
+                        return this.status();
+                    }
+                    this.state = { pending: true, phase: "waiting" };
+                    if (fresh.some(snapshot => snapshot.running === null))
+                        throw new Error("底层组件执行清单不可用，请稍后重试。");
+                    this.state = { pending: true, phase: "updating" };
+                    // Keep accepted input queues and history; invalidate active callbacks
+                    // through their managers before interrupting daemon-owned executions.
+                    o.stopExecutions?.();
+                    const interrupted = await Promise.allSettled(o.targets.map((target, i) => target.interrupt?.(fresh[i])));
+                    for (const result of interrupted)
+                        if (result.status === "rejected")
+                            throw result.reason;
+                    const deadline = Date.now() + 10_000;
+                    while (fresh.some(snapshot => snapshot.running !== 0) || o.coreBusy?.()) {
+                        if (Date.now() >= deadline || this.stopped || !o.available()) {
+                            throw new Error("执行尚未停止，更新未完成。系统会在空闲后自动重试。");
+                        }
+                        await new Promise(resolve => setTimeout(resolve, 50));
+                        fresh = await Promise.all(o.targets.map(target => target.inspect()));
+                    }
+                    for (let i = 0; i < fresh.length; i++) {
+                        if (this.stopped || !o.available())
+                            throw new Error("更新已暂停，请稍后重试。");
+                        if (fresh[i].pending)
+                            await o.targets[i].restart(fresh[i]);
+                    }
+                    const after = await Promise.all(o.targets.map(target => target.inspect()));
+                    if (after.some(snapshot => snapshot.pending))
+                        throw new Error("底层组件更新未完成，请稍后重试。");
+                    this.state = { pending: false, phase: "idle" };
+                    this.failures = 0;
+                    return this.status();
+                }
+                catch (error) {
+                    if (this.state.pending)
+                        this.state = { pending: true, phase: "retrying" };
+                    throw error;
+                }
+                finally {
+                    this.idleSince = null;
+                    releaseCore();
+                }
+            });
+        })().finally(() => { this.forcing = null; });
+        return this.forcing;
     }
     async inspectAndUpdate() {
         const o = this.options;

package/dist/render-daemon-client.d.ts

@@ -108,6 +108,8 @@ export declare class RenderDaemonClient implements TerminalHost {
         sessions: TerminalSessionState[] | null;
     }>;
     requestShutdownDrain(): Promise<void>;
+    /** Explicit confirmed maintenance only; does not shut down the daemon itself. */
+    interruptMaintenanceSessions(): Promise<void>;
     connect(): Promise<void>;
     private open;
     /**

package/dist/render-daemon-client.js

@@ -233,6 +233,12 @@ export class RenderDaemonClient {
     async requestShutdownDrain() {
         await this.request("shutdown", { mode: "drain" });
     }
+    /** Explicit confirmed maintenance only; does not shut down the daemon itself. */
+    async interruptMaintenanceSessions() {
+        const sessions = await this.listSessions();
+        await Promise.all(sessions.filter(session => session.status === "running")
+            .map(session => this.request("kill", { sessionId: session.sessionId, signal: "SIGTERM" })));
+    }
     connect() {
         if (this.disposed)
             return Promise.reject(new Error("Render client disposed"));

package/dist/server-daemon-maintenance-routes.d.ts

@@ -0,0 +1,8 @@
+import type { Express, Request, RequestHandler } from "express";
+import type { DaemonMaintenance } from "./daemon-maintenance.js";
+export declare function registerDaemonMaintenanceRoutes(app: Express, options: {
+    requireAdmin: RequestHandler;
+    canForceUpdate(req: Request): boolean;
+    maintenance: Pick<DaemonMaintenance, "status" | "forceUpdate">;
+    log(error: unknown): void;
+}): void;

package/dist/server-daemon-maintenance-routes.js

@@ -0,0 +1,19 @@
+export function registerDaemonMaintenanceRoutes(app, options) {
+    const { maintenance } = options;
+    app.get("/api/daemon-maintenance", (req, res) => {
+        res.set("Cache-Control", "no-store").json({ ...maintenance.status(), canForceUpdate: options.canForceUpdate(req) });
+    });
+    app.post("/api/daemon-maintenance/force-update", options.requireAdmin, async (req, res) => {
+        if (req.body?.confirmInterrupt !== true) {
+            res.status(400).json({ error: "请先确认中断正在执行的任务。" });
+            return;
+        }
+        try {
+            res.set("Cache-Control", "no-store").json(await maintenance.forceUpdate());
+        }
+        catch (error) {
+            options.log(error);
+            res.status(409).json({ error: "强制更新未完成，执行可能仍在停止或组件暂不可用。系统会在空闲后自动重试。", ...maintenance.status() });
+        }
+    });
+}

package/dist/server.js

@@ -86,6 +86,7 @@ import { TerminalDaemonClient } from "./terminal-daemon-client.js";
 import { createUpgradeAwareTerminalHost } from "./render-host.js";
 import { DaemonAdmission, DaemonMaintenance } from "./daemon-maintenance.js";
 import { createDaemonMaintenanceTargets } from "./daemon-maintenance-targets.js";
+import { registerDaemonMaintenanceRoutes } from "./server-daemon-maintenance-routes.js";
 import { terminalDaemonBuildIsCurrent } from "./terminal-daemon-build.js";
 import { createUpgradeAwareStructuredHost } from "./render-structured-host.js";
 import { checkPasswordRateLimit, recordFailedPassword, resetPasswordRateLimit } from "./middleware/rate-limit.js";
@@ -467,6 +468,17 @@ export async function startServer(config, configPath, options = {}) {
         busy: () => structuredSessions.getCoreTurnStatus().hasActiveTurns
             || [...processes.list(), ...structuredSessions.list()].some((session) => session.status === "running" || session.structuredState?.inFlight === true || (session.queuedMessages?.length ?? 0) > 0),
         beginCoreDrain: () => structuredSessions.beginCoreRestartDrain(),
+        coreBusy: () => structuredSessions.getCoreTurnStatus().hasActiveTurns,
+        stopExecutions: () => {
+            for (const session of structuredSessions.list()) {
+                if (session.status === "running" || session.structuredState?.inFlight)
+                    structuredSessions.stop(session.id);
+            }
+            for (const session of processes.list()) {
+                if (session.status === "running")
+                    processes.stop(session.id);
+            }
+        },
         available: () => !shuttingDown && !updateState.updateInFlight && !updateState.providerCliUpdateInFlight
             && terminalDaemonBuildIsCurrent(),
         log: (error) => wandError("底层组件自动更新暂缓，将稍后重试", getErrorMessage(error)),
@@ -695,9 +707,12 @@ export async function startServer(config, configPath, options = {}) {
     });
     registerDecisionRoutes(app, { storage, decisions: decisionExpert, requireAuth, requireSessions });
     app.use("/api", requireAuth);
-    app.get("/api/daemon-maintenance", (_req, res) => {
-        res.set("Cache-Control", "no-store").json(daemonMaintenance.status());
-    });
+    registerDaemonMaintenanceRoutes(app, { requireAdmin, maintenance: daemonMaintenance,
+        canForceUpdate: req => {
+            const principal = requestPrincipals.get(req);
+            return !!principal && principalHasScope(principal, "admin");
+        },
+        log: error => wandError("底层组件强制更新未完成", getErrorMessage(error)) });
     // Connected apps receive only the route families used by native clients and
     // the browser extension. Browser-admin sessions implicitly satisfy all scopes.
     app.use([