beauticode-dsh 1.0.0

package/vendor/adapter-dsh/session.js

@@ -0,0 +1,527 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ApplyTransaction, BackgroundStore, MediaServerController, buildHostApplyPayload, defaultDataRoot, resolveSessionBundledThemes, } from "../core/index.js";
+import { DshHostApplier, normalizeDshBaseUrl } from "./bridge.js";
+import { DSH_HOST_DESCRIPTOR } from "./host-descriptor.js";
+import { acquireDshInjectorLock } from "./injector-lock.js";
+import { ensureBridgeToken } from "./token.js";
+import { trayHandoffRequested } from "./tray-handoff.js";
+export class DshSession {
+    descriptor = DSH_HOST_DESCRIPTOR;
+    cdpPort = null;
+    dataRoot;
+    verifyDeadlineMs;
+    pollMs;
+    honorTrayHandoff;
+    baseUrl;
+    store;
+    media;
+    host = null;
+    releaseLock = null;
+    watchTimer = null;
+    handoffTimer = null;
+    watchTask = null;
+    stopTask = null;
+    activeOperations = new Set();
+    closed = false;
+    userBusy = false;
+    onError;
+    onStatus;
+    lastWatchError = "";
+    fishMode = false;
+    videoMuted = true;
+    backgroundTone = "auto";
+    activeThemeId = null;
+    lastProgressWriteAt = 0;
+    lastProgressWriteSec = -1;
+    progressWriteInFlight = false;
+    constructor(opts = {}) {
+        this.dataRoot = opts.dataRoot ?? defaultDataRoot();
+        this.verifyDeadlineMs = opts.verifyDeadlineMs ?? 30_000;
+        this.pollMs = opts.pollMs ?? 2_000;
+        this.honorTrayHandoff = opts.honorTrayHandoff !== false;
+        this.baseUrl = normalizeDshBaseUrl(opts.baseUrl ?? "http://127.0.0.1:3080");
+        this.store = new BackgroundStore({
+            root: this.dataRoot,
+            bundledThemes: resolveSessionBundledThemes({
+                enabled: opts.bundledGallery,
+                imagePath: opts.bundledGalleryImagePath,
+                searchRoots: [
+                    path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../.."),
+                    process.cwd(),
+                ],
+            }),
+        });
+        this.media = new MediaServerController({
+            enabled: true,
+            trustedOrigins: [this.baseUrl.origin],
+        });
+        this.onError = opts.onError ?? null;
+        this.onStatus = opts.onStatus ?? null;
+    }
+    get isBusy() {
+        return this.userBusy;
+    }
+    get isOpen() {
+        return !this.closed && this.releaseLock != null;
+    }
+    get isHostReady() {
+        return (this.host?.activeSessionCount ?? 0) > 0;
+    }
+    async start() {
+        if (this.closed)
+            throw new Error("Session already stopped");
+        if (this.releaseLock)
+            throw new Error("Session already started");
+        await this.store.init();
+        this.releaseLock = await acquireDshInjectorLock(this.dataRoot);
+        try {
+            const token = await ensureBridgeToken(this.dataRoot);
+            this.host = new DshHostApplier({
+                baseUrl: this.baseUrl.href,
+                token,
+                pollMs: Math.min(250, Math.max(50, Math.floor(this.pollMs / 4))),
+            });
+        }
+        catch (error) {
+            await this.releaseLock().catch(() => { });
+            this.releaseLock = null;
+            throw error;
+        }
+        this.startWatchLoop();
+        if (this.honorTrayHandoff) {
+            this.startHandoffLoop();
+            void this.yieldToTrayIfRequested();
+        }
+        void this.watchOnce();
+        return { port: this.bridgePort() };
+    }
+    async apply(input) {
+        return this.trackOperation(this.applyInternal(input));
+    }
+    async applyInternal(input) {
+        if (!this.releaseLock || this.closed || !this.host) {
+            throw new Error("Session is not started");
+        }
+        if (this.userBusy) {
+            return {
+                ok: false,
+                error: "Another background apply is already in progress.",
+                rolledBack: false,
+            };
+        }
+        this.userBusy = true;
+        try {
+            const tx = new ApplyTransaction({
+                store: this.store,
+                media: this.media,
+                host: this.host,
+                verifyDeadlineMs: this.verifyDeadlineMs,
+                offline: false,
+            });
+            const result = await tx.run(input);
+            if (result.ok) {
+                this.activeThemeId = null;
+                this.lastProgressWriteSec = -1;
+                if (input.type === "clear") {
+                    this.fishMode = false;
+                }
+                else if (this.fishMode) {
+                    await this.host.setFishMode(true).catch(() => null);
+                }
+                if (!this.videoMuted || input.type === "video") {
+                    await this.host.setMuted(this.videoMuted).catch(() => null);
+                }
+                if (input.type === "image" && input.effects?.preset === "infernal") {
+                    this.backgroundTone = "dark";
+                }
+                else if (input.type === "image" && input.effects?.preset === "internal") {
+                    this.backgroundTone = "light";
+                }
+                await this.host.setBackgroundTone(this.backgroundTone).catch(() => null);
+            }
+            return result;
+        }
+        finally {
+            this.userBusy = false;
+        }
+    }
+    async reapply() {
+        return this.trackOperation(this.reapplyInternal());
+    }
+    async reapplyInternal() {
+        if (!this.releaseLock || this.closed || !this.host) {
+            throw new Error("Session is not started");
+        }
+        if (this.userBusy) {
+            return {
+                ok: false,
+                error: "Another background apply is already in progress.",
+                rolledBack: false,
+            };
+        }
+        this.userBusy = true;
+        let stagedImage = null;
+        let stagedVideo = null;
+        try {
+            const manifest = await this.store.readActiveManifest();
+            let resumeAt = null;
+            if (manifest.background?.type === "video") {
+                try {
+                    const position = await this.host.getPlaybackPosition();
+                    if (position.ok && position.hasVideo && Number.isFinite(position.currentTime)) {
+                        resumeAt = Math.max(0, position.currentTime);
+                    }
+                }
+                catch {
+                    /* Fall back to the bound saved theme below. */
+                }
+                if (resumeAt == null && this.activeThemeId) {
+                    resumeAt = await this.store.getSavedThemeVideoPosition(this.activeThemeId);
+                }
+            }
+            if (manifest.background) {
+                stagedImage = await this.media.stage(path.join(this.store.paths.activeDir, manifest.background.image));
+                if (manifest.background.type === "video" && manifest.background.video) {
+                    const runtimeVideoPath = await this.store.prepareRuntimeVideo(manifest);
+                    if (!runtimeVideoPath) {
+                        throw new Error("DSH video reapply requires a detached runtime copy.");
+                    }
+                    stagedVideo = await this.media.stage(runtimeVideoPath);
+                }
+            }
+            const staged = { image: stagedImage, video: stagedVideo };
+            const payload = await buildHostApplyPayload(this.store, manifest, staged, "");
+            if (payload.video && resumeAt != null)
+                payload.video.startAt = resumeAt;
+            await this.host.apply(payload);
+            const verify = await this.host.verify({
+                generation: manifest.generation,
+                media: manifest.background?.type ?? "clear",
+            }, { deadlineMs: this.verifyDeadlineMs });
+            if (verify.status !== "pass") {
+                await this.media.abort(stagedVideo);
+                await this.media.abort(stagedImage);
+                stagedVideo = null;
+                stagedImage = null;
+                return {
+                    ok: false,
+                    error: `Live verify did not pass (${verify.status}): ${verify.reason}`,
+                    rolledBack: false,
+                };
+            }
+            await this.media.commit(staged);
+            stagedVideo = null;
+            stagedImage = null;
+            if (!manifest.background) {
+                this.fishMode = false;
+                this.activeThemeId = null;
+            }
+            else if (this.fishMode) {
+                await this.host.setFishMode(true).catch(() => null);
+            }
+            await this.host.setMuted(this.videoMuted).catch(() => null);
+            await this.host.setBackgroundTone(this.backgroundTone).catch(() => null);
+            return {
+                ok: true,
+                generation: manifest.generation,
+                mode: manifest.background?.type ?? "clear",
+            };
+        }
+        catch (error) {
+            await this.media.abort(stagedVideo);
+            await this.media.abort(stagedImage);
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+                rolledBack: false,
+            };
+        }
+        finally {
+            this.userBusy = false;
+        }
+    }
+    async status() {
+        const manifest = await this.store.readActiveManifest();
+        if (this.host)
+            await this.host.status().catch(() => null);
+        return {
+            host: this.descriptor,
+            port: this.bridgePort(),
+            sessions: this.host?.activeSessionCount ?? 0,
+            manifest,
+            mediaServer: this.media.activeImage?.url ?? this.media.activeVideo?.url ?? null,
+            fish: this.fishMode,
+            muted: this.videoMuted,
+            tone: this.backgroundTone,
+        };
+    }
+    async saveCurrentTheme(name) {
+        let videoPositionSec = null;
+        if (this.host) {
+            try {
+                const position = await this.host.getPlaybackPosition();
+                if (position.ok && position.hasVideo && Number.isFinite(position.currentTime)) {
+                    videoPositionSec = position.currentTime;
+                }
+            }
+            catch {
+                /* Save without a resume position when no browser client is available. */
+            }
+        }
+        const theme = await this.store.saveCurrentTheme(name, { videoPositionSec });
+        if (theme.type === "video") {
+            this.activeThemeId = theme.id;
+            this.lastProgressWriteSec = -1;
+        }
+        else {
+            this.activeThemeId = null;
+        }
+        return theme;
+    }
+    async listSavedThemes() {
+        return this.store.listSavedThemes();
+    }
+    async deleteSavedTheme(themeId) {
+        const deleted = await this.store.deleteSavedTheme(themeId);
+        if (deleted && this.activeThemeId === themeId) {
+            this.activeThemeId = null;
+            this.lastProgressWriteSec = -1;
+        }
+        return deleted;
+    }
+    async useSavedTheme(themeId) {
+        try {
+            const saved = await this.store.loadSavedTheme(themeId);
+            const result = await this.apply(saved.input);
+            if (result.ok) {
+                this.activeThemeId = saved.input.type === "video" ? saved.themeId : null;
+                this.lastProgressWriteSec = -1;
+            }
+            return result;
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+                rolledBack: false,
+            };
+        }
+    }
+    async setFishMode(enabled) {
+        if (!this.releaseLock || this.closed || !this.host) {
+            return { ok: false, fish: this.fishMode, sessions: 0, error: "Session is not started" };
+        }
+        const want = Boolean(enabled);
+        if (want) {
+            const manifest = await this.store.readActiveManifest();
+            if (!manifest.background) {
+                this.fishMode = false;
+                return {
+                    ok: false,
+                    fish: false,
+                    sessions: 0,
+                    error: "No active background. Apply an image or video first.",
+                };
+            }
+        }
+        this.fishMode = want;
+        try {
+            const result = await this.host.setFishMode(want);
+            if (result.ok)
+                this.fishMode = result.fish;
+            else if (!want)
+                this.fishMode = false;
+            return result;
+        }
+        catch (error) {
+            return {
+                ok: false,
+                fish: this.fishMode,
+                sessions: 0,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async setMuted(muted) {
+        if (!this.releaseLock || this.closed || !this.host) {
+            return {
+                ok: false,
+                muted: this.videoMuted,
+                blocked: false,
+                sessions: 0,
+                error: "Session is not started",
+            };
+        }
+        this.videoMuted = Boolean(muted);
+        try {
+            const result = await this.host.setMuted(this.videoMuted);
+            if (result.ok)
+                this.videoMuted = result.muted;
+            return result;
+        }
+        catch (error) {
+            return {
+                ok: false,
+                muted: this.videoMuted,
+                blocked: false,
+                sessions: 0,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async setBackgroundTone(tone) {
+        if (!this.releaseLock || this.closed || !this.host) {
+            return { ok: false, tone: this.backgroundTone, sessions: 0, error: "Session is not started" };
+        }
+        this.backgroundTone = tone === "light" || tone === "auto" ? tone : "dark";
+        try {
+            const result = await this.host.setBackgroundTone(this.backgroundTone);
+            if (result.ok)
+                this.backgroundTone = result.tone;
+            return result;
+        }
+        catch (error) {
+            return {
+                ok: false,
+                tone: this.backgroundTone,
+                sessions: 0,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async stop() {
+        if (this.stopTask)
+            return this.stopTask;
+        this.stopTask = this.stopExclusive();
+        return this.stopTask;
+    }
+    async stopExclusive() {
+        this.closed = true;
+        if (this.watchTimer)
+            clearInterval(this.watchTimer);
+        this.watchTimer = null;
+        if (this.handoffTimer)
+            clearInterval(this.handoffTimer);
+        this.handoffTimer = null;
+        await Promise.allSettled([this.watchTask, ...this.activeOperations].filter((value) => Boolean(value)));
+        if (this.fishMode && this.host) {
+            await this.host.setFishMode(false).catch(() => null);
+            this.fishMode = false;
+        }
+        await this.media.close().catch(() => { });
+        if (this.releaseLock)
+            await this.releaseLock().catch(() => { });
+        this.releaseLock = null;
+        this.host = null;
+    }
+    trackOperation(operation) {
+        this.activeOperations.add(operation);
+        void operation.finally(() => this.activeOperations.delete(operation)).catch(() => { });
+        return operation;
+    }
+    bridgePort() {
+        if (this.baseUrl.port)
+            return Number(this.baseUrl.port);
+        return 80;
+    }
+    startWatchLoop() {
+        this.watchTimer = setInterval(() => void this.watchOnce(), this.pollMs);
+        this.watchTimer.unref?.();
+    }
+    startHandoffLoop() {
+        this.handoffTimer = setInterval(() => void this.yieldToTrayIfRequested(), 250);
+        this.handoffTimer.unref?.();
+    }
+    async yieldToTrayIfRequested() {
+        if (this.closed || this.stopTask)
+            return;
+        if (!(await trayHandoffRequested(this.dataRoot)))
+            return;
+        this.onStatus?.("beautiCode 托盘正在接管，正在释放本机会话。");
+        await this.stop();
+    }
+    async watchOnce() {
+        if (this.closed || !this.host || this.watchTask)
+            return;
+        const task = (async () => {
+            try {
+                const [status, manifest] = await Promise.all([
+                    this.host.status(),
+                    this.store.readActiveManifest(),
+                ]);
+                this.lastWatchError = "";
+                const media = manifest.background?.type ?? "clear";
+                // Media URLs are process-local. After the tray/session host restarts,
+                // the DSH page may still report the same generation while pointing at
+                // a dead loopback server, so force one reapply when local handles are
+                // absent.
+                const localMediaMissing = media === "image"
+                    ? this.media.activeImage == null
+                    : media === "video"
+                        ? this.media.activeImage == null || this.media.activeVideo == null
+                        : false;
+                const stale = status.connectedClients > 0 &&
+                    (status.current?.generation !== manifest.generation ||
+                        status.current.media !== media ||
+                        localMediaMissing);
+                if (stale && !this.userBusy) {
+                    this.onStatus?.("DeepSeek Harness 已连接，正在恢复当前背景。");
+                    const result = await this.reapply();
+                    if (!result.ok)
+                        throw new Error(result.error);
+                }
+                await this.persistBoundThemeProgress();
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                if (err.message !== this.lastWatchError) {
+                    this.lastWatchError = err.message;
+                    this.onError?.(err);
+                }
+            }
+        })();
+        this.watchTask = task;
+        await task.finally(() => {
+            if (this.watchTask === task)
+                this.watchTask = null;
+        });
+    }
+    async persistBoundThemeProgress() {
+        if (!this.activeThemeId || !this.host || this.progressWriteInFlight || this.userBusy) {
+            return;
+        }
+        const now = Date.now();
+        if (now - this.lastProgressWriteAt < 2_000)
+            return;
+        this.progressWriteInFlight = true;
+        try {
+            const position = await this.host.getPlaybackPosition();
+            if (!position.ok || !position.hasVideo)
+                return;
+            let seconds = Number(position.currentTime);
+            if (!Number.isFinite(seconds) || seconds < 0)
+                return;
+            if (position.duration > 0 && seconds >= position.duration - 0.25)
+                seconds = 0;
+            if (this.lastProgressWriteSec >= 0 &&
+                Math.abs(seconds - this.lastProgressWriteSec) < 0.5 &&
+                !(seconds === 0 && this.lastProgressWriteSec !== 0)) {
+                this.lastProgressWriteAt = now;
+                return;
+            }
+            const result = await this.store.updateSavedThemeVideoPosition(this.activeThemeId, seconds);
+            if (result.ok) {
+                this.lastProgressWriteAt = now;
+                this.lastProgressWriteSec = result.positionSec ?? seconds;
+            }
+            else if (result.error === "Saved theme not found.") {
+                this.activeThemeId = null;
+            }
+        }
+        finally {
+            this.progressWriteInFlight = false;
+        }
+    }
+}
+//# sourceMappingURL=session.js.map

package/vendor/adapter-dsh/token.js

@@ -0,0 +1,46 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+export const DSH_BRIDGE_TOKEN_FILE = "dsh-bridge.token";
+const TOKEN_PATTERN = /^[a-f0-9]{64}$/;
+export function bridgeTokenPath(dataRoot) {
+    return path.join(dataRoot, DSH_BRIDGE_TOKEN_FILE);
+}
+async function readToken(file) {
+    const token = (await fs.readFile(file, "utf8")).trim();
+    if (!TOKEN_PATTERN.test(token)) {
+        throw new Error("DeepSeek Harness bridge token file is invalid.");
+    }
+    return token;
+}
+/** Create once with owner-only permissions where the platform supports them. */
+export async function ensureBridgeToken(dataRoot) {
+    await fs.mkdir(dataRoot, { recursive: true });
+    const file = bridgeTokenPath(dataRoot);
+    try {
+        return await readToken(file);
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+    }
+    const token = crypto.randomBytes(32).toString("hex");
+    try {
+        const handle = await fs.open(file, "wx", 0o600);
+        try {
+            await handle.writeFile(`${token}\n`, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        return token;
+    }
+    catch (error) {
+        if (error?.code === "EEXIST") {
+            return readToken(file);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=token.js.map

package/vendor/adapter-dsh/tray-handoff.js

@@ -0,0 +1,54 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export const TRAY_CLAIM_FILE = "tray-claim.json";
+export const TRAY_CLAIM_SCHEMA = "beauticode.tray-claim/v1";
+export const SESSION_HOST_FILE = "session-host.json";
+export const SESSION_HOST_SCHEMA = "beauticode.session-host/v1";
+export const DSH_CONTROL_FILE = "dsh-control.json";
+export const DSH_CONTROL_SCHEMA = "beauticode.dsh-control/v1";
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return Boolean(error && typeof error === "object" && "code" in error && error.code === "EPERM");
+    }
+}
+async function readLivePid(filePath, schema) {
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (schema && parsed.schema !== schema)
+            return null;
+        const pid = Number(parsed.pid);
+        if (!Number.isInteger(pid) || pid <= 0 || !isPidAlive(pid))
+            return null;
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when the tray is starting or a different session-host owns the data root. */
+export async function trayHandoffRequested(dataRoot, selfPid = process.pid) {
+    const root = path.resolve(dataRoot);
+    const claimPid = await readLivePid(path.join(root, TRAY_CLAIM_FILE), TRAY_CLAIM_SCHEMA);
+    // In-process sessions never write this file; any live claim means the tray wants the lock.
+    if (claimPid != null)
+        return true;
+    const hostPid = await readLivePid(path.join(root, SESSION_HOST_FILE), SESSION_HOST_SCHEMA);
+    if (hostPid != null && hostPid !== selfPid)
+        return true;
+    const controlPid = await readLivePid(path.join(root, DSH_CONTROL_FILE), DSH_CONTROL_SCHEMA);
+    return controlPid != null && controlPid !== selfPid;
+}
+//# sourceMappingURL=tray-handoff.js.map