@co0ontty/wand 4.3.0 → 4.4.0-beta.g4c9bbce

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "18f9ba6ad046ce59dc68669d11daf26d39e23f11",
-  "builtAt": "2026-07-15T07:37:39.130Z",
-  "version": "4.3.0",
-  "channel": "stable"
+  "commit": "4c9bbce65ef02fdc9b8b5d2891e8839f0f2a74a2",
+  "builtAt": "2026-07-15T13:05:18.468Z",
+  "version": "4.4.0-beta.g4c9bbce",
+  "channel": "beta"
 }

package/dist/distribution-manager.d.ts

@@ -0,0 +1,50 @@
+import type { WandConfig } from "./types.js";
+export type ApkUpdateChannel = "stable" | "beta";
+export interface LocalDistributionAsset {
+    fileName: string;
+    filePath: string;
+    size: number;
+    updatedAt: string;
+    version: string | null;
+    downloadUrl: string;
+    source: "local";
+}
+export interface ResolvedDistributionAsset {
+    version: string;
+    downloadUrl: string;
+    fileName: string;
+    size: number;
+    source: "local" | "github";
+    releaseNotes?: string;
+}
+export interface DistributionSettings {
+    androidApk: Record<string, unknown>;
+    macosDmg: Record<string, unknown>;
+}
+export interface DistributionManagerOptions {
+    configDir: string;
+    configPath: string;
+    config: WandConfig;
+    repositoryUrl: string;
+    fetch?: typeof fetch;
+    now?: () => number;
+}
+export declare class DistributionManager {
+    private readonly options;
+    private readonly fetchImpl;
+    private readonly now;
+    private readonly githubCache;
+    constructor(options: DistributionManagerOptions);
+    resolveLatestApk(channel: ApkUpdateChannel): Promise<ResolvedDistributionAsset | null>;
+    resolveAndroidDownload(channel?: ApkUpdateChannel): Promise<LocalDistributionAsset | null>;
+    resolveLatestDmg(): Promise<ResolvedDistributionAsset | null>;
+    resolveMacosDownload(): Promise<LocalDistributionAsset | null>;
+    getSettings(): Promise<DistributionSettings>;
+    private refreshConfig;
+    private resolveLocalAsset;
+    private readLocalAsset;
+    private fetchGitHubAsset;
+    private fetchGitHubReleaseAsset;
+    private buildSettings;
+    private publicAsset;
+}

package/dist/distribution-manager.js

@@ -0,0 +1,276 @@
+import { mkdir, readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { compareApkInstallOrder, compareSemver, extractSemver } from "./version-utils.js";
+const GITHUB_CACHE_TTL_MS = 10 * 60 * 1000;
+function asRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function resolveConfiguredDir(configDir, configuredDir, fallback) {
+    const value = configuredDir?.trim();
+    if (!value)
+        return path.join(configDir, fallback);
+    return path.isAbsolute(value) ? value : path.resolve(configDir, value);
+}
+function extractArtifactVersion(fileName, extension) {
+    return extractSemver(fileName.replace(new RegExp(`\\${extension}$`, "i"), ""));
+}
+function isPrerelease(version) {
+    return !!version && version.includes("-");
+}
+export class DistributionManager {
+    options;
+    fetchImpl;
+    now;
+    githubCache = new Map();
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl = options.fetch ?? fetch;
+        this.now = options.now ?? Date.now;
+    }
+    async resolveLatestApk(channel) {
+        const [localApk, githubApk] = await Promise.all([
+            this.resolveAndroidDownload(channel),
+            this.fetchGitHubAsset(".apk"),
+        ]);
+        const local = localApk?.version ? {
+            version: localApk.version,
+            downloadUrl: `${localApk.downloadUrl}?channel=${channel}`,
+            fileName: localApk.fileName,
+            size: localApk.size,
+            source: "local",
+        } : null;
+        const github = githubApk ? { ...githubApk, source: "github" } : null;
+        if (local && github) {
+            return compareApkInstallOrder(github.version, local.version) > 0 ? github : local;
+        }
+        return local ?? github;
+    }
+    async resolveAndroidDownload(channel = "beta") {
+        await this.refreshConfig();
+        const { config, configDir } = this.options;
+        if (config.android?.enabled !== true)
+            return null;
+        const directory = resolveConfiguredDir(configDir, config.android.apkDir, "android");
+        return this.resolveLocalAsset({
+            directory,
+            extension: ".apk",
+            configuredFile: channel === "beta" ? "" : config.android.currentApkFile,
+            downloadUrl: "/android/download",
+            compareVersions: compareApkInstallOrder,
+            acceptVersion: channel === "stable" ? (version) => !isPrerelease(version) : undefined,
+        });
+    }
+    async resolveLatestDmg() {
+        const localDmg = await this.resolveMacosDownload();
+        if (localDmg?.version) {
+            return {
+                version: localDmg.version,
+                downloadUrl: localDmg.downloadUrl,
+                fileName: localDmg.fileName,
+                size: localDmg.size,
+                source: "local",
+            };
+        }
+        const github = await this.fetchGitHubAsset(".dmg");
+        return github ? { ...github, source: "github" } : null;
+    }
+    async resolveMacosDownload() {
+        await this.refreshConfig();
+        const { config, configDir } = this.options;
+        if (config.macos?.enabled !== true)
+            return null;
+        return this.resolveLocalAsset({
+            directory: resolveConfiguredDir(configDir, config.macos.dmgDir, "macos"),
+            extension: ".dmg",
+            configuredFile: config.macos.currentDmgFile,
+            downloadUrl: "/macos/download",
+            compareVersions: compareSemver,
+        });
+    }
+    async getSettings() {
+        const [localApk, githubApk, localDmg, githubDmg] = await Promise.all([
+            this.resolveAndroidDownload("beta"),
+            this.fetchGitHubAsset(".apk"),
+            this.resolveMacosDownload(),
+            this.fetchGitHubAsset(".dmg"),
+        ]);
+        const apkDir = resolveConfiguredDir(this.options.configDir, this.options.config.android?.apkDir, "android");
+        const dmgDir = resolveConfiguredDir(this.options.configDir, this.options.config.macos?.dmgDir, "macos");
+        return {
+            androidApk: this.buildSettings("apk", apkDir, this.options.config.android?.enabled === true, localApk, githubApk),
+            macosDmg: this.buildSettings("dmg", dmgDir, this.options.config.macos?.enabled === true, localDmg, githubDmg),
+        };
+    }
+    async refreshConfig() {
+        let raw;
+        try {
+            raw = JSON.parse(await readFile(this.options.configPath, "utf8"));
+        }
+        catch {
+            return;
+        }
+        const { config } = this.options;
+        const android = asRecord(raw.android);
+        if (android) {
+            config.android = { ...(config.android ?? {}) };
+            if (typeof android.enabled === "boolean")
+                config.android.enabled = android.enabled;
+            if (Object.hasOwn(android, "apkDir")) {
+                config.android.apkDir = typeof android.apkDir === "string" && android.apkDir.trim() ? android.apkDir.trim() : "android";
+            }
+            if (Object.hasOwn(android, "currentApkFile")) {
+                config.android.currentApkFile = typeof android.currentApkFile === "string" ? android.currentApkFile.trim() : "";
+            }
+        }
+        const macos = asRecord(raw.macos);
+        if (macos) {
+            config.macos = { ...(config.macos ?? {}) };
+            if (typeof macos.enabled === "boolean")
+                config.macos.enabled = macos.enabled;
+            if (Object.hasOwn(macos, "dmgDir")) {
+                config.macos.dmgDir = typeof macos.dmgDir === "string" && macos.dmgDir.trim() ? macos.dmgDir.trim() : "macos";
+            }
+            if (Object.hasOwn(macos, "currentDmgFile")) {
+                config.macos.currentDmgFile = typeof macos.currentDmgFile === "string" ? macos.currentDmgFile.trim() : "";
+            }
+        }
+    }
+    async resolveLocalAsset(options) {
+        await mkdir(options.directory, { recursive: true });
+        const configuredFile = options.configuredFile?.trim();
+        if (configuredFile) {
+            return this.readLocalAsset(path.join(options.directory, path.basename(configuredFile)), options);
+        }
+        const entries = await readdir(options.directory, { withFileTypes: true });
+        const files = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(options.extension));
+        const candidates = (await Promise.all(files.map(async (entry) => {
+            const filePath = path.join(options.directory, entry.name);
+            return { entry, filePath, fileStat: await stat(filePath) };
+        }))).filter(({ entry }) => options.acceptVersion?.(extractArtifactVersion(entry.name, options.extension)) ?? true);
+        if (candidates.length === 0)
+            return null;
+        candidates.sort((a, b) => {
+            const aVersion = extractArtifactVersion(a.entry.name, options.extension);
+            const bVersion = extractArtifactVersion(b.entry.name, options.extension);
+            if (aVersion && bVersion) {
+                const comparison = options.compareVersions(bVersion, aVersion);
+                if (comparison !== 0)
+                    return comparison;
+            }
+            else if (aVersion) {
+                return -1;
+            }
+            else if (bVersion) {
+                return 1;
+            }
+            return b.fileStat.mtimeMs - a.fileStat.mtimeMs;
+        });
+        const selected = candidates[0];
+        return {
+            fileName: selected.entry.name,
+            filePath: selected.filePath,
+            size: selected.fileStat.size,
+            updatedAt: selected.fileStat.mtime.toISOString(),
+            version: extractArtifactVersion(selected.entry.name, options.extension),
+            downloadUrl: options.downloadUrl,
+            source: "local",
+        };
+    }
+    async readLocalAsset(filePath, options) {
+        try {
+            const fileStat = await stat(filePath);
+            if (!fileStat.isFile())
+                return null;
+            const fileName = path.basename(filePath);
+            const version = extractArtifactVersion(fileName, options.extension);
+            if (options.acceptVersion && !options.acceptVersion(version))
+                return null;
+            return {
+                fileName,
+                filePath,
+                size: fileStat.size,
+                updatedAt: fileStat.mtime.toISOString(),
+                version,
+                downloadUrl: options.downloadUrl,
+                source: "local",
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async fetchGitHubAsset(extension) {
+        const cached = this.githubCache.get(extension);
+        if (cached && this.now() - cached.timestamp < GITHUB_CACHE_TTL_MS)
+            return cached.asset;
+        try {
+            const hit = await this.fetchGitHubReleaseAsset(extension);
+            if (!hit)
+                return cached?.asset ?? null;
+            const version = extractArtifactVersion(hit.asset.name, extension)
+                ?? extractArtifactVersion(hit.tagName, extension)
+                ?? hit.tagName.replace(/^v/, "");
+            const asset = {
+                version,
+                downloadUrl: hit.asset.browser_download_url,
+                fileName: hit.asset.name,
+                size: hit.asset.size,
+                ...(extension === ".apk" && hit.body ? { releaseNotes: hit.body.trim().slice(0, 500) } : {}),
+            };
+            this.githubCache.set(extension, { asset, timestamp: this.now() });
+            return asset;
+        }
+        catch {
+            return cached?.asset ?? null;
+        }
+    }
+    async fetchGitHubReleaseAsset(extension) {
+        const apiUrl = this.options.repositoryUrl.replace("github.com", "api.github.com/repos") + "/releases?per_page=30";
+        const response = await this.fetchImpl(apiUrl, {
+            headers: { Accept: "application/vnd.github.v3+json", "User-Agent": "wand-server" },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok)
+            return null;
+        const releases = await response.json();
+        for (const release of releases) {
+            if (release.draft || release.prerelease)
+                continue;
+            const asset = release.assets.find((candidate) => candidate.name.toLowerCase().endsWith(extension));
+            if (asset)
+                return { tagName: release.tag_name, body: release.body, asset };
+        }
+        return null;
+    }
+    buildSettings(kind, directory, enabled, local, github) {
+        const selected = local
+            ? { ...local, source: "local" }
+            : github
+                ? { ...github, updatedAt: null, source: "github" }
+                : null;
+        const hasKey = kind === "apk" ? "hasApk" : "hasDmg";
+        const dirKey = kind === "apk" ? "apkDir" : "dmgDir";
+        return {
+            enabled,
+            [dirKey]: directory,
+            [hasKey]: selected !== null,
+            fileName: selected?.fileName ?? null,
+            version: selected?.version ?? null,
+            size: selected?.size ?? null,
+            updatedAt: selected?.updatedAt ?? null,
+            downloadUrl: selected?.downloadUrl ?? null,
+            source: selected?.source ?? null,
+            local: local ? this.publicAsset(local) : null,
+            github: github ? this.publicAsset(github) : null,
+        };
+    }
+    publicAsset(asset) {
+        return {
+            fileName: asset.fileName,
+            version: asset.version,
+            size: asset.size,
+            ...("updatedAt" in asset ? { updatedAt: asset.updatedAt } : {}),
+            downloadUrl: asset.downloadUrl,
+        };
+    }
+}

package/dist/server-session-routes.js

@@ -959,7 +959,27 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         const shortcutKey = body.shortcutKey;
         try {
             if (structured.get(sessionId)) {
-                const snapshot = await structured.sendMessage(sessionId, input);
+                const completion = structured.sendMessage(sessionId, input);
+                if (body.respondImmediately === true) {
+                    // sendMessage updates the canonical snapshot synchronously before it
+                    // starts awaiting the runner. Native clients should not hold this
+                    // request open for an entire model turn (which can exceed their HTTP
+                    // timeout, especially while the first-turn title job is also active).
+                    // The normal structured events continue to carry progress/failure.
+                    completion.catch((error) => {
+                        console.error("[wand] Accepted structured input later failed", {
+                            sessionId,
+                            error: getInputDebugMeta(error),
+                        });
+                    });
+                    const accepted = structured.get(sessionId);
+                    if (!accepted) {
+                        throw new Error("未找到该结构化会话。");
+                    }
+                    res.status(202).json(sessionResponseDTO(accepted));
+                    return;
+                }
+                const snapshot = await completion;
                 res.json(sessionResponseDTO(snapshot));
                 return;
             }