@co0ontty/wand 3.1.1 → 4.0.0

package/dist/server-settings-routes.d.ts

@@ -0,0 +1,43 @@
+import type { Express, Request, RequestHandler } from "express";
+import { type ModelRefreshOptions } from "./models.js";
+import { type RuntimeConfigState } from "./runtime-config.js";
+import type { WandStorage } from "./storage.js";
+import type { WandConfig } from "./types.js";
+interface SettingsDistributionPayload {
+    androidApk: Record<string, unknown>;
+    macosDmg: Record<string, unknown>;
+}
+interface SettingsBuildInfo {
+    commit: string | null;
+    builtAt: string | null;
+    channel: string | null;
+}
+export interface ServerSettingsRoutesDependencies {
+    storage: WandStorage;
+    config: WandConfig;
+    runtimeConfig: RuntimeConfigState;
+    configPath: string;
+    configDir: string;
+    requireAdmin: RequestHandler;
+    requireAdminOrSessionPreferences: RequestHandler;
+    packageInfo: {
+        version: string;
+        name: string;
+        nodeVersion: string;
+        repoUrl: string;
+    };
+    buildInfo: SettingsBuildInfo;
+    getCachedUpdateInfo(): {
+        updateAvailable: boolean;
+        latest: string | null;
+    } | null;
+    getUpdateChannel(): "stable" | "beta";
+    getDistributionSettings(): Promise<SettingsDistributionPayload>;
+    getModelRefreshOptions(): ModelRefreshOptions;
+    resolveAppConnectCode(req: Request): {
+        code: string;
+        url: string;
+    };
+}
+export declare function registerSettingsRoutes(app: Express, deps: ServerSettingsRoutesDependencies): void;
+export {};

package/dist/server-settings-routes.js

@@ -0,0 +1,225 @@
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { buildChildEnv } from "./env-utils.js";
+import { getErrorMessage } from "./error-utils.js";
+import { asyncRoute } from "./express-async.js";
+import { getProviderDefaultModels, PREFERENCE_KEYS, saveConfig, writePreferenceToStorage, } from "./config.js";
+import { getCachedModels, refreshModels } from "./models.js";
+import { DEPLOYMENT_CONFIG_KEYS } from "./runtime-config.js";
+function publicConfig(config) {
+    const { password: _password, appSecret: _appSecret, ...safe } = config;
+    const defaultModels = getProviderDefaultModels(config);
+    return {
+        ...safe,
+        defaultModel: defaultModels.claude,
+        defaultCodexModel: defaultModels.codex,
+        defaultOpenCodeModel: defaultModels.opencode,
+        defaultModels,
+    };
+}
+export function registerSettingsRoutes(app, deps) {
+    const { storage, config, runtimeConfig, configPath, configDir, requireAdmin, requireAdminOrSessionPreferences, } = deps;
+    app.get("/api/settings", requireAdmin, asyncRoute(async (_req, res) => {
+        const desiredConfig = runtimeConfig.desiredSnapshot();
+        const distribution = await deps.getDistributionSettings();
+        const cachedUpdate = deps.getCachedUpdateInfo();
+        res.json({
+            version: deps.packageInfo.version,
+            packageName: deps.packageInfo.name,
+            nodeVersion: deps.packageInfo.nodeVersion,
+            repoUrl: deps.packageInfo.repoUrl,
+            config: publicConfig(desiredConfig),
+            desiredConfig: publicConfig(desiredConfig),
+            activeConfig: publicConfig(config),
+            restartRequired: runtimeConfig.hasPendingRestart(),
+            hasCert: existsSync(path.join(configDir, "server.key")) && existsSync(path.join(configDir, "server.crt")),
+            updateAvailable: cachedUpdate?.updateAvailable ?? false,
+            latestVersion: cachedUpdate?.latest ?? null,
+            updateChannel: deps.getUpdateChannel(),
+            build: {
+                ...deps.buildInfo,
+                shortCommit: deps.buildInfo.commit ? deps.buildInfo.commit.slice(0, 7) : null,
+            },
+            autoUpdate: {
+                web: storage.getConfigValue("autoUpdateWeb") === "true",
+                apk: storage.getConfigValue("autoUpdateApk") === "true",
+                dmg: storage.getConfigValue("autoUpdateDmg") === "true",
+                cli: storage.getConfigValue("autoUpdateProviderClis") === "true",
+            },
+            ...distribution,
+        });
+    }));
+    app.get("/api/settings/env-preview", (req, res, next) => {
+        if (req.query.reveal === "1")
+            return requireAdmin(req, res, next);
+        next();
+    }, (req, res) => {
+        const inheritEnv = config.inheritEnv !== false;
+        const env = buildChildEnv(inheritEnv, {
+            WAND_MODE: "<runtime>",
+            WAND_AUTO_CONFIRM: "<runtime>",
+            WAND_AUTO_EDIT: "<runtime>",
+        });
+        const reveal = req.query.reveal === "1" || req.query.reveal === "true";
+        const sensitivePattern = /(KEY|TOKEN|SECRET|PASSWORD|AUTH|CREDENTIAL|COOKIE|SESSION)/i;
+        const entries = Object.keys(env).sort().map((name) => {
+            const raw = env[name] ?? "";
+            const sensitive = sensitivePattern.test(name);
+            const placeholder = raw.startsWith("<") && raw.endsWith(">");
+            return {
+                name,
+                value: sensitive && !reveal && !placeholder ? "***" : raw,
+                length: raw.length,
+                sensitive,
+            };
+        });
+        res.json({ inheritEnv, total: entries.length, reveal, entries });
+    });
+    app.get("/api/app-connect-code", requireAdmin, (req, res) => {
+        res.json(deps.resolveAppConnectCode(req));
+    });
+    app.post("/api/settings/config", requireAdminOrSessionPreferences, asyncRoute(async (req, res) => {
+        const body = req.body;
+        const previousDesiredConfig = runtimeConfig.desiredSnapshot();
+        const candidateConfig = runtimeConfig.createCandidate();
+        const stagedPreferences = [];
+        const stagedPreferenceFields = new Set();
+        const stagingStorage = {
+            setPreference(key, value) { stagedPreferences.push({ key, value }); },
+        };
+        const stagePreference = (field, value) => {
+            writePreferenceToStorage(candidateConfig, stagingStorage, field, value);
+            stagedPreferenceFields.add(field);
+        };
+        let touchedDeployField = false;
+        try {
+            for (const field of DEPLOYMENT_CONFIG_KEYS) {
+                if (!(field in body) || body[field] === undefined)
+                    continue;
+                if (field === "port") {
+                    const port = Number(body.port);
+                    if (!Number.isInteger(port) || port < 1 || port > 65535)
+                        throw new Error(`无效端口号: ${body.port}`);
+                    candidateConfig.port = port;
+                }
+                else if (field === "https") {
+                    if (typeof body.https !== "boolean")
+                        throw new Error("https 必须是布尔值。");
+                    candidateConfig.https = body.https;
+                }
+                else if (field === "host") {
+                    if (typeof body.host !== "string" || !body.host.trim())
+                        throw new Error("host 不能为空。");
+                    candidateConfig.host = body.host.trim();
+                }
+                else if (field === "shell") {
+                    if (typeof body.shell !== "string" || !body.shell.trim())
+                        throw new Error("shell 不能为空。");
+                    candidateConfig.shell = body.shell.trim();
+                }
+                touchedDeployField = true;
+            }
+            if (body.defaultModels !== undefined) {
+                if (!body.defaultModels || typeof body.defaultModels !== "object" || Array.isArray(body.defaultModels)) {
+                    throw new Error("defaultModels 必须是对象。");
+                }
+                if (Object.hasOwn(body.defaultModels, "claude"))
+                    stagePreference("defaultModel", body.defaultModels.claude);
+                if (Object.hasOwn(body.defaultModels, "codex"))
+                    stagePreference("defaultCodexModel", body.defaultModels.codex);
+                if (Object.hasOwn(body.defaultModels, "opencode"))
+                    stagePreference("defaultOpenCodeModel", body.defaultModels.opencode);
+            }
+            for (const field of PREFERENCE_KEYS) {
+                const value = body[field];
+                if (!(field in body) || value === undefined)
+                    continue;
+                stagePreference(field, value);
+            }
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "配置校验失败。") });
+            return;
+        }
+        if (!touchedDeployField && stagedPreferences.length === 0) {
+            res.status(400).json({ error: "没有可更新的配置字段。" });
+            return;
+        }
+        let deployConfigWritten = false;
+        try {
+            if (touchedDeployField) {
+                await saveConfig(configPath, candidateConfig);
+                deployConfigWritten = true;
+            }
+            if (stagedPreferences.length > 0) {
+                storage.transaction(() => {
+                    for (const mutation of stagedPreferences)
+                        storage.setPreference(mutation.key, mutation.value);
+                });
+            }
+            runtimeConfig.commit(candidateConfig, stagedPreferenceFields);
+            res.json({
+                ok: true,
+                config: publicConfig(candidateConfig),
+                desiredConfig: publicConfig(candidateConfig),
+                activeConfig: publicConfig(config),
+                restartRequired: runtimeConfig.hasPendingRestart(),
+            });
+        }
+        catch (error) {
+            if (deployConfigWritten) {
+                try {
+                    await saveConfig(configPath, previousDesiredConfig);
+                }
+                catch { /* preserve original */ }
+            }
+            res.status(500).json({ error: getErrorMessage(error, "保存配置失败。") });
+        }
+    }));
+    app.get("/api/models", (_req, res) => {
+        const cached = getCachedModels(deps.getModelRefreshOptions());
+        const defaults = getProviderDefaultModels(config);
+        res.json({
+            ...cached,
+            defaultModel: defaults.claude,
+            defaultCodexModel: defaults.codex,
+            defaultOpenCodeModel: defaults.opencode,
+            defaultModels: defaults,
+        });
+    });
+    app.post("/api/models/refresh", asyncRoute(async (_req, res) => {
+        try {
+            const refreshed = await refreshModels({ ...deps.getModelRefreshOptions(), verifyClaudeCandidates: true });
+            const defaults = getProviderDefaultModels(config);
+            res.json({
+                ...refreshed,
+                defaultModel: defaults.claude,
+                defaultCodexModel: defaults.codex,
+                defaultOpenCodeModel: defaults.opencode,
+                defaultModels: defaults,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "刷新模型列表失败。") });
+        }
+    }));
+    app.post("/api/settings/upload-cert", requireAdmin, asyncRoute(async (req, res) => {
+        const { key, cert } = req.body;
+        if (!key || !cert) {
+            res.status(400).json({ error: "请提供 key 和 cert 内容。" });
+            return;
+        }
+        if (!key.includes("-----BEGIN") || !cert.includes("-----BEGIN")) {
+            res.status(400).json({ error: "证书内容格式无效，请上传 PEM 格式的文件。" });
+            return;
+        }
+        try {
+            writeFileSync(path.join(configDir, "server.key"), key, { mode: 0o600 });
+            writeFileSync(path.join(configDir, "server.crt"), cert, { mode: 0o600 });
+            res.json({ ok: true, restartRequired: true });
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "保存证书失败。") });
+        }
+    }));
+}

package/dist/server-update-routes.d.ts

@@ -0,0 +1,61 @@
+import type { Express, RequestHandler } from "express";
+import { type ModelRefreshOptions } from "./models.js";
+import type { PackageUpdateInfo, UpdateChannel } from "./npm-update-utils.js";
+import { type ProviderCliUpdateStatus } from "./provider-cli-updater.js";
+import type { WandStorage } from "./storage.js";
+import type { WandConfig } from "./types.js";
+interface DownloadAsset {
+    fileName: string;
+    filePath: string;
+    size: number;
+}
+interface ResolvedUpdateAsset {
+    version: string;
+    downloadUrl: string;
+    fileName: string;
+    size: number;
+    source: "local" | "github";
+    releaseNotes?: string;
+}
+export interface PublicUpdateRoutesDependencies {
+    resolveLatestApk(channel: "stable" | "beta"): Promise<ResolvedUpdateAsset | null>;
+    resolveAndroidDownload(channel: "stable" | "beta"): Promise<DownloadAsset | null>;
+    resolveLatestDmg(): Promise<ResolvedUpdateAsset | null>;
+    resolveMacosDownload(): Promise<DownloadAsset | null>;
+}
+export declare function registerPublicUpdateRoutes(app: Express, deps: PublicUpdateRoutesDependencies): void;
+export declare class ServerUpdateState {
+    providerCliUpdateCache: {
+        items: ProviderCliUpdateStatus[];
+        checkedAt: string;
+    } | null;
+    providerCliUpdateInFlight: boolean;
+    updateInFlight: boolean;
+}
+export declare function refreshProviderCliUpdateState(state: ServerUpdateState, config: WandConfig): Promise<{
+    items: ProviderCliUpdateStatus[];
+    checkedAt: string;
+}>;
+export interface AdminUpdateRoutesDependencies {
+    storage: WandStorage;
+    config: WandConfig;
+    configPath: string;
+    requireAdmin: RequestHandler;
+    state: ServerUpdateState;
+    getDistributionSettings(): Promise<{
+        androidApk: Record<string, unknown>;
+        macosDmg: Record<string, unknown>;
+    }>;
+    getModelRefreshOptions(): ModelRefreshOptions;
+    getUpdateChannel(): UpdateChannel;
+    checkLatestPackageVersion(channel: UpdateChannel, forceRefresh?: boolean): Promise<PackageUpdateInfo>;
+    buildInfo: {
+        commit: string | null;
+        builtAt: string | null;
+        channel: string | null;
+    };
+    serverInstanceId: string;
+    emitSystemNotification(data: Record<string, unknown>): void;
+}
+export declare function registerAdminUpdateRoutes(app: Express, deps: AdminUpdateRoutesDependencies): void;
+export {};

package/dist/server-update-routes.js

@@ -0,0 +1,215 @@
+import { getErrorMessage } from "./error-utils.js";
+import { asyncRoute } from "./express-async.js";
+import { refreshModels } from "./models.js";
+import { checkProviderCliUpdates, updateProviderClis, verifyProviderCliUpdateResults, } from "./provider-cli-updater.js";
+import { streamFileWithRange } from "./server-file-routes.js";
+import { compareSemver } from "./version-utils.js";
+import { canUseDetachedUpdateHelper, startDetachedUpdateHelper } from "./update-helper.js";
+export function registerPublicUpdateRoutes(app, deps) {
+    app.get("/api/android-apk-update", asyncRoute(async (req, res) => {
+        const currentVersion = typeof req.query.currentVersion === "string" ? req.query.currentVersion.trim() : "";
+        if (!currentVersion) {
+            res.status(400).json({ error: "Missing currentVersion query parameter." });
+            return;
+        }
+        const channel = req.query.channel === "beta" ? "beta" : "stable";
+        const latest = await deps.resolveLatestApk(channel);
+        if (!latest) {
+            res.json({ updateAvailable: false, currentVersion, latestVersion: null, downloadUrl: null, source: null, channel });
+            return;
+        }
+        const updateAvailable = compareSemver(latest.version, currentVersion) > 0;
+        res.json({
+            updateAvailable,
+            currentVersion,
+            latestVersion: latest.version,
+            downloadUrl: updateAvailable ? latest.downloadUrl : null,
+            fileName: updateAvailable ? latest.fileName : null,
+            size: updateAvailable ? latest.size : null,
+            source: latest.source,
+            channel,
+            releaseNotes: updateAvailable ? (latest.releaseNotes ?? null) : null,
+        });
+    }));
+    app.get("/android/download", asyncRoute(async (req, res) => {
+        const channel = req.query.channel === "stable" ? "stable" : "beta";
+        const asset = await deps.resolveAndroidDownload(channel);
+        if (!asset) {
+            res.status(404).json({ error: "当前没有可下载的 APK 文件。" });
+            return;
+        }
+        streamFileWithRange(req, res, {
+            filePath: asset.filePath,
+            size: asset.size,
+            contentType: "application/vnd.android.package-archive",
+            disposition: `attachment; filename="${encodeURIComponent(asset.fileName)}"`,
+            readErrorMessage: "读取 APK 文件失败。",
+        });
+    }));
+    app.get("/api/macos-dmg-update", asyncRoute(async (req, res) => {
+        const currentVersion = typeof req.query.currentVersion === "string" ? req.query.currentVersion.trim() : "";
+        if (!currentVersion) {
+            res.status(400).json({ error: "Missing currentVersion query parameter." });
+            return;
+        }
+        const latest = await deps.resolveLatestDmg();
+        if (!latest) {
+            res.json({ updateAvailable: false, currentVersion, latestVersion: null, downloadUrl: null, source: null });
+            return;
+        }
+        const updateAvailable = compareSemver(latest.version, currentVersion) > 0;
+        res.json({
+            updateAvailable,
+            currentVersion,
+            latestVersion: latest.version,
+            downloadUrl: updateAvailable ? latest.downloadUrl : null,
+            fileName: updateAvailable ? latest.fileName : null,
+            size: updateAvailable ? latest.size : null,
+            source: latest.source,
+        });
+    }));
+    app.get("/macos/download", asyncRoute(async (req, res) => {
+        const asset = await deps.resolveMacosDownload();
+        if (!asset) {
+            res.status(404).json({ error: "当前没有可下载的 DMG 文件。" });
+            return;
+        }
+        streamFileWithRange(req, res, {
+            filePath: asset.filePath,
+            size: asset.size,
+            contentType: "application/x-apple-diskimage",
+            disposition: `attachment; filename="${encodeURIComponent(asset.fileName)}"`,
+            readErrorMessage: "读取 DMG 文件失败。",
+        });
+    }));
+}
+export class ServerUpdateState {
+    providerCliUpdateCache = null;
+    providerCliUpdateInFlight = false;
+    updateInFlight = false;
+}
+export async function refreshProviderCliUpdateState(state, config) {
+    const items = await checkProviderCliUpdates({ inheritEnv: config.inheritEnv !== false });
+    const result = { items, checkedAt: new Date().toISOString() };
+    state.providerCliUpdateCache = result;
+    return result;
+}
+export function registerAdminUpdateRoutes(app, deps) {
+    const { state, config, storage, requireAdmin } = deps;
+    app.get("/api/android-apk", requireAdmin, asyncRoute(async (_req, res) => {
+        res.json((await deps.getDistributionSettings()).androidApk);
+    }));
+    app.get("/api/macos-dmg", requireAdmin, asyncRoute(async (_req, res) => {
+        res.json((await deps.getDistributionSettings()).macosDmg);
+    }));
+    app.get("/api/provider-cli-updates", requireAdmin, asyncRoute(async (req, res) => {
+        try {
+            const force = req.query.refresh === "1" || !state.providerCliUpdateCache;
+            const data = force
+                ? await refreshProviderCliUpdateState(state, config)
+                : state.providerCliUpdateCache;
+            res.json({
+                ...data,
+                updating: state.providerCliUpdateInFlight,
+                autoUpdate: storage.getConfigValue("autoUpdateProviderClis") === "true",
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "检查 CLI 更新失败。") });
+        }
+    }));
+    app.post("/api/provider-cli-updates", requireAdmin, asyncRoute(async (req, res) => {
+        if (state.providerCliUpdateInFlight || state.updateInFlight) {
+            res.status(409).json({ error: "CLI 更新正在进行中，请稍候。" });
+            return;
+        }
+        const rawIds = Array.isArray(req.body?.ids) ? req.body.ids : [];
+        const ids = rawIds.filter((value) => value === "claude" || value === "codex" || value === "opencode");
+        state.providerCliUpdateInFlight = true;
+        try {
+            const before = await refreshProviderCliUpdateState(state, config);
+            const commandResults = await updateProviderClis(before.items, ids.length ? ids : undefined, {
+                inheritEnv: config.inheritEnv !== false,
+                onLog: (line) => process.stdout.write(`[wand] ${line}\n`),
+            });
+            const after = await refreshProviderCliUpdateState(state, config);
+            const results = verifyProviderCliUpdateResults(commandResults, after.items);
+            void refreshModels(deps.getModelRefreshOptions()).catch(() => { });
+            res.json({ ok: results.every((item) => item.ok), results, ...after, autoUpdate: storage.getConfigValue("autoUpdateProviderClis") === "true" });
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "更新 CLI 失败。") });
+        }
+        finally {
+            state.providerCliUpdateInFlight = false;
+        }
+    }));
+    app.get("/api/check-update", requireAdmin, asyncRoute(async (_req, res) => {
+        try {
+            const info = await deps.checkLatestPackageVersion(deps.getUpdateChannel(), true);
+            res.json({
+                ...info,
+                build: {
+                    ...deps.buildInfo,
+                    shortCommit: deps.buildInfo.commit ? deps.buildInfo.commit.slice(0, 7) : null,
+                },
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "检查更新失败。") });
+        }
+    }));
+    app.post("/api/update", requireAdmin, asyncRoute(async (_req, res) => {
+        if (state.updateInFlight || state.providerCliUpdateInFlight) {
+            res.status(409).json({ error: "更新正在进行中，请稍候。" });
+            return;
+        }
+        state.updateInFlight = true;
+        try {
+            const info = await deps.checkLatestPackageVersion(deps.getUpdateChannel(), true);
+            if (!info.latest) {
+                res.status(502).json({ error: "无法连接到 npm registry。" });
+                return;
+            }
+            if (!canUseDetachedUpdateHelper()) {
+                res.status(500).json({ error: "当前平台暂不支持 Web 异步更新，请在终端运行 install.sh 更新。" });
+                return;
+            }
+            const helper = startDetachedUpdateHelper({
+                installSpec: info.installSpec,
+                configPath: deps.configPath,
+                parentPid: process.pid,
+                cliArgs: process.argv.slice(2),
+                cwd: process.cwd(),
+                env: process.env,
+                timeoutMs: 300000,
+            });
+            if (!helper.started) {
+                res.status(500).json({ error: helper.message, detail: `script=${helper.scriptPath}\nlog=${helper.logPath}` });
+                return;
+            }
+            process.stdout.write(`[wand] ${helper.message}\n`);
+            deps.emitSystemNotification({
+                kind: "auto-update-restart",
+                current: info.current,
+                latest: info.latest,
+                previousInstanceId: deps.serverInstanceId,
+            });
+            res.json({
+                ok: true,
+                message: info.updateAvailable ? `已开始更新到 ${info.latest}` : `已开始重新安装 ${info.latest}`,
+                restartRequired: false,
+                detachedUpdate: true,
+                version: info.latest,
+                previousInstanceId: deps.serverInstanceId,
+                logPath: helper.logPath,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "更新失败。") });
+        }
+        finally {
+            state.updateInFlight = false;
+        }
+    }));
+}

package/dist/server.d.ts

@@ -1,10 +1,9 @@
+import { AuthService } from "./auth.js";
+import { ModelRefreshOptions } from "./models.js";
 import { ProcessManager } from "./process-manager.js";
 import { StructuredSessionManager } from "./structured-session-manager.js";
-import { WandStorage } from "./storage.js";
 import { type PathRepairResult } from "./path-repair.js";
 import { WandConfig } from "./types.js";
-/** Persist a cwd to recent paths. Used by both REST and session creation hooks. */
-export declare function recordRecentPath(storage: WandStorage, cwd: string | undefined | null): void;
 export interface ServerUrl {
     url: string;
     scheme: "HTTP" | "HTTPS";
@@ -12,6 +11,7 @@ export interface ServerUrl {
 export interface ServerHandle {
     processManager: ProcessManager;
     structuredSessions: StructuredSessionManager;
+    authService: AuthService;
     configPath: string;
     dbPath: string;
     urls: ServerUrl[];
@@ -29,4 +29,6 @@ export declare class PortInUseError extends Error {
     constructor(port: number, host: string);
 }
 export declare function isPortInUseError(error: unknown): error is PortInUseError;
-export declare function startServer(config: WandConfig, configPath: string): Promise<ServerHandle>;
+export declare function startServer(config: WandConfig, configPath: string, options?: {
+    modelRefreshOptions?: () => Partial<ModelRefreshOptions>;
+}): Promise<ServerHandle>;