@playcraft/cli 0.1.11 → 0.1.13

package/dist/utils/agent-api-client.js

@@ -1,5 +1,5 @@
 import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
 import { homedir } from 'os';
 import { loadGlobalConfig } from '../config.js';
 import { DEFAULT_PLAYCRAFT_CLOUD_BASE } from '../commands/login.js';
@@ -18,8 +18,8 @@ function isPatToken(token) {
  * or from the CLI after `playcraft login`.
  *
  * 凭证解析优先级：
- *   API URL : PLAYCRAFT_API_URL → .playcraft.json → ~/.playcraft/config.json → DEFAULT_PLAYCRAFT_CLOUD_BASE
- *   Token   : PLAYCRAFT_SANDBOX_TOKEN → .playcraft.json token → ~/.playcraft/config.json token (PAT)
+ *   API URL : PLAYCRAFT_API_URL → sandbox global .playcraft.json → project .playcraft.json → ~/.playcraft/config.json → DEFAULT_PLAYCRAFT_CLOUD_BASE
+ *   Token   : PLAYCRAFT_SANDBOX_TOKEN → sandbox global .playcraft.json → project .playcraft.json → ~/.playcraft/config.json token (PAT)
  *
  * 鉴权 header 自动选择：
  *   - 沙箱 JWT (非 PAT) → X-Sandbox-Token: <token>（后端 @SandboxToken 路由的沙箱分支）
@@ -28,7 +28,7 @@ function isPatToken(token) {
 export class AgentApiClient {
     apiUrl;
     token;
-    isPat;
+    credentialFile;
     playcraftEnv;
     constructor() {
         const localConfig = AgentApiClient.loadLocalConfig();
@@ -39,7 +39,7 @@ export class AgentApiClient {
             globalConfig.backendUrl ||
             globalConfig.url ||
             DEFAULT_PLAYCRAFT_CLOUD_BASE).replace(/\/+$/, '');
-        // Token: 沙箱 token 环境变量 → 本地 .playcraft.json → 全局 login 配置（PAT）
+        // Token: 环境变量 → 沙箱全局配置 → 项目配置 → 用户登录配置
         const token = process.env.PLAYCRAFT_SANDBOX_TOKEN ||
             localConfig.token ||
             globalConfig.token ||
@@ -50,14 +50,22 @@ export class AgentApiClient {
         }
         this.apiUrl = apiUrl;
         this.token = token;
-        this.isPat = isPatToken(token);
+        this.credentialFile = localConfig.credentialFile;
         this.playcraftEnv = (process.env.PLAYCRAFT_ENV || localConfig.env || '').trim();
     }
     /** 根据 token 类型构造鉴权 headers */
     authHeaders() {
-        const headers = this.isPat
-            ? { Authorization: `Bearer ${this.token}` }
-            : { 'X-Sandbox-Token': this.token };
+        let token = this.token;
+        // Polling commands can outlive a credential: read the atomically refreshed file per request.
+        if (this.credentialFile && !process.env.PLAYCRAFT_SANDBOX_TOKEN) {
+            try {
+                token = JSON.parse(readFileSync(this.credentialFile, 'utf8')).token || token;
+            }
+            catch { /* Keep the last credential if a local file is temporarily unavailable. */ }
+        }
+        const headers = isPatToken(token)
+            ? { Authorization: `Bearer ${token}` }
+            : { 'X-Sandbox-Token': token };
         if (this.playcraftEnv) {
             headers['playcraft-env'] = this.playcraftEnv;
         }
@@ -196,15 +204,22 @@ export class AgentApiClient {
      * 与全局 login 配置（~/.playcraft/config.json）不同，前者专用于沙箱 token。
      */
     static loadLocalConfig() {
+        const ancestors = [];
+        for (let directory = process.cwd();; directory = dirname(directory)) {
+            ancestors.push(join(directory, '.playcraft.json'));
+            if (dirname(directory) === directory)
+                break;
+        }
         const searchPaths = [
-            join(process.cwd(), '.playcraft.json'),
+            process.env.PLAYCRAFT_SANDBOX_CONFIG_PATH || '/workspaces/.playcraft.json',
+            ...ancestors,
             '/project/.playcraft.json',
             join(homedir(), '.playcraft.json'),
         ];
         for (const p of searchPaths) {
             if (existsSync(p)) {
                 try {
-                    return JSON.parse(readFileSync(p, 'utf-8'));
+                    return { ...JSON.parse(readFileSync(p, 'utf-8')), credentialFile: p };
                 }
                 catch {
                     continue;

package/dist/workspace-runtime/codex/app-server.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { startLauncherProcess } from './launcher-client.js';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -8,6 +8,8 @@ import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
 import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
 import { collectedEvent, NativePreparationError } from './native-adapter.js';
 import { exportTranscript } from './transcripts.js';
+import { readProjectSkillsLockFile } from '@playcraft/common/project-skills';
+import { freezeWorkspaceSkills } from '../workspaces/skills.js';
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -62,6 +64,8 @@ export function createCodexAppServerAdapter(options) {
     let readyFlag = false;
     let closed = false;
     let startPromise;
+    let skillsRestartFailed = false;
+    let preparationQueue = Promise.resolve();
     let live;
     const exitListeners = new Set();
     const collected = new Set();
@@ -69,6 +73,18 @@ export function createCodexAppServerAdapter(options) {
         for (const listener of collected)
             listener(event);
     }
+    async function withPreparation(action) {
+        const previous = preparationQueue;
+        let release;
+        preparationQueue = new Promise(resolve => { release = resolve; });
+        await previous;
+        try {
+            return await action();
+        }
+        finally {
+            release();
+        }
+    }
     function transcriptHome() {
         if (!launcherSocket)
             return { homeDir };
@@ -82,6 +98,10 @@ export function createCodexAppServerAdapter(options) {
         };
     }
     async function ensureStarted() {
+        if (closed)
+            throw new Error('codex_not_started');
+        if (skillsRestartFailed)
+            throw new NativePreparationError('workspace_skills_unavailable');
         if (readyFlag && rpc)
             return;
         startPromise ??= start();
@@ -98,9 +118,100 @@ export function createCodexAppServerAdapter(options) {
                 ? reason : 'model_credential_unavailable');
         }
     }
+    async function lockedThreadConfig(cwd) {
+        const modelConfig = await threadConfig(cwd);
+        // Single-workspace legacy runners retain their prior behaviour until explicitly adopted.
+        if (await readProjectSkillsLockFile(cwd) === null) {
+            if (options.config.workspaceMode === 'multi')
+                throw new NativePreparationError('workspace_skills_unavailable');
+            return { params: modelConfig, skillsHash: undefined, discoveryHash: undefined };
+        }
+        try {
+            const frozen = await freezeWorkspaceSkills(cwd, join(options.config.stateDir, 'skill-artifacts'), options.loadSkillArtifact ? entry => options.loadSkillArtifact(cwd, entry) : undefined);
+            if (!rpc)
+                throw new Error('codex_not_started');
+            const found = await rpc.request('skills/list', { cwds: [cwd], forceReload: true }, 30_000);
+            const listing = found.data.find(item => item.cwd === cwd);
+            if (!listing || listing.errors.length)
+                throw new Error('workspace_skills_unavailable');
+            // Native scanning is used only to disable paths. Availability comes exclusively from the lock.
+            const config = { ...('config' in modelConfig ? modelConfig.config : {}),
+                'skills.include_instructions': false,
+                'skills.config': listing.skills.map(skill => ({ path: skill.path, enabled: false })) };
+            const developerInstructions = [
+                `Available workspace skills are fixed by lock ${frozen.declarationHash}.`,
+                'Use only the following locked skills. Read its SKILL.md when a skill applies, and resolve supporting files relative to that file. Disabled and unlisted skill directories are not available.',
+                ...frozen.skills.map(skill => JSON.stringify(skill)),
+                ...(frozen.skills.length ? [] : ['(No workspace skills are enabled.)']),
+            ].join('\n');
+            const discoveryHash = createHash('sha256').update(JSON.stringify(listing.skills.map(skill => skill.path).sort())).digest('hex');
+            return { params: { ...modelConfig, config, developerInstructions }, skillsHash: frozen.lockHash, discoveryHash };
+        }
+        catch {
+            throw new NativePreparationError('workspace_skills_unavailable');
+        }
+    }
+    async function restartForSkills(threadId) {
+        if ([...threads.values()].some(thread => thread.turnActive) || approvals.size)
+            throw new NativePreparationError('skills_reload_pending');
+        const previous = live;
+        if (previous)
+            previous.superseded = true;
+        readyFlag = false;
+        await previous?.rpc.close();
+        await previous?.child.stop();
+        if (closed)
+            throw new Error('codex_not_started');
+        rpc = undefined;
+        startPromise = undefined;
+        for (const thread of threads.values()) {
+            thread.loaded = false;
+            thread.needsRecreate = !thread.hasNativeHistory;
+        }
+        // A controlled idle restart retains the runtime epoch and all durable thread identities.
+        try {
+            startPromise = start();
+            await startPromise;
+            if (closed)
+                throw new Error('codex_not_started');
+            if (!live)
+                throw new NativePreparationError('workspace_skills_unavailable');
+            await options.onSkillProcessRestart?.({ pid: live.pid, startedAt: live.startedAt });
+            if (closed)
+                throw new Error('codex_not_started');
+            // Other workspaces resume lazily, so a damaged unrelated lock cannot block this workspace.
+            const thread = threads.get(threadId);
+            if (thread?.hasNativeHistory && thread.cwd)
+                await resumePreparedThread(threadId, thread, await lockedThreadConfig(thread.cwd));
+        }
+        catch {
+            readyFlag = false;
+            skillsRestartFailed = true;
+            if (live) {
+                live.superseded = true;
+                await live.rpc.close();
+                await live.child.stop();
+            }
+            throw new NativePreparationError('workspace_skills_unavailable');
+        }
+    }
+    async function resumePreparedThread(threadId, thread, prepared) {
+        const resumed = await rpc.request('thread/resume', {
+            threadId, cwd: thread.cwd, ...prepared.params,
+        }, 30_000);
+        if (resumed.thread?.id !== threadId)
+            throw new NativePreparationError('workspace_skills_unavailable');
+        thread.loaded = true;
+        thread.skillsHash = prepared.skillsHash;
+        thread.discoveryHash = prepared.discoveryHash;
+    }
     async function start() {
+        if (closed)
+            throw new Error('codex_not_started');
         await options.modelBroker?.start();
         const token = options.modelBroker ? 'workspace-broker-managed' : await readToken(options);
+        if (closed)
+            throw new Error('codex_not_started');
         const bin = options.command || process.env.PLAYCRAFT_CODEX_BIN || (launcherSocket ? '/usr/local/bin/codex' : 'codex');
         const { command, prefix } = spawnCommand(bin);
         const args = [...prefix, ...(options.args ?? ['app-server'])];
@@ -131,6 +242,8 @@ export function createCodexAppServerAdapter(options) {
         }
         else {
             await writePlaycraftCodexConfig({ homeDir, modelProxyUrl: options.config.modelProxyUrl, model });
+            if (closed)
+                throw new Error('codex_not_started');
             const local = spawn(command, args, {
                 cwd: options.config.workspaceRoot,
                 env: { ...process.env, ...options.env, CODEX_HOME: homeDir, OPENAI_API_KEY: token, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
@@ -147,11 +260,25 @@ export function createCodexAppServerAdapter(options) {
                 },
             };
         }
+        if (closed) {
+            await child.stop();
+            throw new Error('codex_not_started');
+        }
         child.stderr?.on('data', (chunk) => {
             process.stderr.write(chunk);
         });
         rpc = createJsonRpcStdioClient(child);
         rpc.onNotification((method, params) => {
+            if (method === 'turn/completed') {
+                const record = asRecord(params), turnId = asRecord(record.turn).id;
+                const thread = typeof record.threadId === 'string' ? threads.get(record.threadId)
+                    : [...threads.values()].find(item => item.lastTurnId === turnId);
+                if (thread) {
+                    thread.turnActive = false;
+                    if (typeof turnId === 'string')
+                        thread.lastCompletedTurnId = turnId;
+                }
+            }
             emitCollected(collectedEvent('notification', method, params));
         });
         rpc.onServerRequest((id, method, params) => {
@@ -182,7 +309,8 @@ export function createCodexAppServerAdapter(options) {
                 readyFlag = false;
                 // Retain the old handle until its entire execution group is confirmed stopped.
                 rpc = undefined;
-                emitCollected(collectedEvent('process_exit', 'process.exited', { pid: current.pid }));
+                if (!current.superseded)
+                    emitCollected(collectedEvent('process_exit', 'process.exited', { pid: current.pid }));
             }
             if (!current.superseded && !closed) {
                 for (const listener of exitListeners)
@@ -197,6 +325,8 @@ export function createCodexAppServerAdapter(options) {
                     version: options.config.cliVersion,
                 },
             });
+            if (closed)
+                throw new Error('codex_not_started');
             rpc.notify('initialized', {});
             readyFlag = true;
         }
@@ -237,6 +367,7 @@ export function createCodexAppServerAdapter(options) {
             if (previous)
                 await previous.child.stop();
             executionEpoch += 1;
+            skillsRestartFailed = false;
             if (closed)
                 throw new Error('codex_not_started');
             try {
@@ -253,21 +384,38 @@ export function createCodexAppServerAdapter(options) {
             return { pid: next.pid, startedAt: next.startedAt };
         },
         async canContinueThread(input) {
-            await ensureStarted();
-            if (!rpc)
-                return false;
-            try {
-                const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
-                    ...await threadConfig(input.cwd ?? '') }, 30_000);
-                const resumedId = result.thread?.id ?? result.threadId;
-                if (resumedId !== input.threadId)
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
                     return false;
-                threads.set(input.threadId, { sessionId: input.sessionId });
-                return true;
-            }
-            catch {
-                return false;
-            }
+                try {
+                    const prepared = await lockedThreadConfig(input.cwd ?? '');
+                    const existing = threads.get(input.threadId);
+                    if (existing && existing.sessionId !== input.sessionId)
+                        return false;
+                    if (existing?.needsRecreate)
+                        return false;
+                    if (existing?.loaded) {
+                        if (existing.skillsHash !== prepared.skillsHash || existing.discoveryHash !== prepared.discoveryHash) {
+                            if (!existing.hasNativeHistory)
+                                return false;
+                            await restartForSkills(input.threadId);
+                        }
+                        return threads.get(input.threadId)?.sessionId === input.sessionId;
+                    }
+                    const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
+                        ...prepared.params }, 30_000);
+                    const resumedId = result.thread?.id ?? result.threadId;
+                    if (resumedId !== input.threadId)
+                        return false;
+                    threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
+                        discoveryHash: prepared.discoveryHash, hasNativeHistory: true, loaded: true });
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
         },
         async readThread(input) {
             try {
@@ -300,44 +448,80 @@ export function createCodexAppServerAdapter(options) {
             await ensureStarted();
         },
         async startThread(input) {
-            await ensureStarted();
-            if (!rpc)
-                throw new Error('codex_not_started');
-            const result = await rpc.request('thread/start', {
-                cwd: input.cwd,
-                model,
-                ...await threadConfig(input.cwd),
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
+                    throw new Error('codex_not_started');
+                const prepared = await lockedThreadConfig(input.cwd);
+                const result = await rpc.request('thread/start', {
+                    cwd: input.cwd,
+                    model,
+                    ...prepared.params,
+                });
+                const threadId = result.thread?.id;
+                if (!threadId)
+                    throw new Error('native_receipt_lost');
+                threads.set(threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
+                    discoveryHash: prepared.discoveryHash, hasNativeHistory: false, loaded: true });
+                return { threadId };
             });
-            const threadId = result.thread?.id;
-            if (!threadId)
-                throw new Error('native_receipt_lost');
-            threads.set(threadId, { sessionId: input.sessionId });
-            return { threadId };
         },
         async startTurn(input) {
-            await ensureStarted();
-            if (!rpc)
-                throw new Error('codex_not_started');
-            if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
-                return { outcome: 'failed', error: 'unknown_thread' };
-            }
-            const requestId = rpc.reserveRequest();
-            await input.persistReservation({ nativeRequestId: String(requestId) });
-            if (input.simulateLostReceipt)
-                return { outcome: 'uncertain', threadId: input.threadId };
-            try {
-                const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [{ type: 'text', text: input.text }] }, turnTimeoutMs);
-                const turnId = started.turn?.id;
-                if (!turnId)
-                    return { outcome: 'uncertain', threadId: input.threadId };
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
+                    throw new Error('codex_not_started');
+                if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
+                    return { outcome: 'failed', error: 'unknown_thread' };
+                }
                 const thread = threads.get(input.threadId);
-                if (thread)
-                    thread.lastTurnId = turnId;
-                return { outcome: 'accepted', threadId: input.threadId, turnId };
-            }
-            catch {
-                return { outcome: 'uncertain', threadId: input.threadId };
-            }
+                if (thread.needsRecreate)
+                    return { outcome: 'failed', error: 'workspace_skills_changed' };
+                if (thread.skillsHash && thread.cwd) {
+                    try {
+                        const prepared = await lockedThreadConfig(thread.cwd);
+                        // Codex does not persist an empty thread rollout until its first turn.
+                        if (!thread.hasNativeHistory) {
+                            if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)
+                                return { outcome: 'failed', error: 'workspace_skills_changed' };
+                        }
+                        else if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash) {
+                            await restartForSkills(input.threadId);
+                        }
+                        if (!thread.loaded)
+                            await resumePreparedThread(input.threadId, thread, prepared);
+                        thread.skillsHash = prepared.skillsHash;
+                        thread.discoveryHash = prepared.discoveryHash;
+                    }
+                    catch (error) {
+                        return { outcome: 'failed', error: error instanceof NativePreparationError ? error.message : 'workspace_skills_unavailable' };
+                    }
+                }
+                const requestId = rpc.reserveRequest();
+                await input.persistReservation({ nativeRequestId: String(requestId) });
+                if (input.simulateLostReceipt)
+                    return { outcome: 'uncertain', threadId: input.threadId };
+                try {
+                    thread.turnActive = true;
+                    const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [
+                            { type: 'text', text: input.text },
+                            ...(input.images ?? []).map((path) => ({ type: 'localImage', path })),
+                        ] }, turnTimeoutMs);
+                    const turnId = started.turn?.id;
+                    if (!turnId)
+                        return { outcome: 'uncertain', threadId: input.threadId };
+                    const acceptedThread = threads.get(input.threadId);
+                    if (acceptedThread) {
+                        acceptedThread.lastTurnId = turnId;
+                        acceptedThread.hasNativeHistory = true;
+                        acceptedThread.turnActive = acceptedThread.lastCompletedTurnId !== turnId;
+                    }
+                    return { outcome: 'accepted', threadId: input.threadId, turnId };
+                }
+                catch {
+                    return { outcome: 'uncertain', threadId: input.threadId };
+                }
+            });
         },
         async interrupt(input) {
             await ensureStarted();

package/dist/workspace-runtime/serve.js

@@ -1,3 +1,4 @@
+import { closeCliCredentials } from './workspaces/cli-credentials.js';
 import { randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { createServer } from 'node:http';
@@ -16,6 +17,9 @@ import { WorkspaceGitCredentialBroker } from './workspaces/git-credential-broker
 import { WorkspaceModelBroker } from './codex/model-broker.js';
 import { recoverInterruptedPreviews } from './previews/publish.js';
 import { recoverInterruptedInstalls } from './workspaces/dependencies.js';
+import { loadWorkspaceSkillArtifact } from './workspaces/skill-artifact-loader.js';
+import { workspaceRoot } from './workspaces/registry.js';
+import { basename } from 'node:path';
 export async function startWorkspaceRuntime(config, options = {}) {
     process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
     const negotiated = negotiateProtocol(config);
@@ -116,6 +120,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
             state,
             url: `http://${formatHost(config.listen.host)}:${port}`,
             async close() {
+                await closeCliCredentials(state);
                 await gitCredentials?.close();
                 disposeDesktopHost(state);
                 disposeTerminalHost(state);
@@ -175,6 +180,13 @@ function defaultNativeAdapter(state) {
         || (!process.env.PLAYCRAFT_NATIVE_ADAPTER && managed)) {
         return createCodexAppServerAdapter({ config,
             ...(managed ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
+            loadSkillArtifact: async (cwd, entry) => {
+                const id = basename(cwd);
+                if (await workspaceRoot(state, id) !== cwd)
+                    throw new Error('workspace_skills_unavailable');
+                return loadWorkspaceSkillArtifact(state, id, entry);
+            },
+            onSkillProcessRestart: process => state.journal.noteExecutionGroup(process),
         });
     }
     return undefined;

package/dist/workspace-runtime/server/desktop-host.js

@@ -2,6 +2,7 @@ import { connect as connectTcp } from 'node:net';
 import { WebSocket, WebSocketServer } from 'ws';
 import { desktopHealthSchema, desktopResourceName, runtimeError, } from '@playcraft/common/cloud-workspace/runtime';
 import { controlTokenMatches, extractControlToken } from './auth.js';
+import { createRfbWatchGate } from './rfb-watch-gate.js';
 /**
  * A takeover holds the desktop for this long, whether or not a page is watching, and ends on its
  * own unless the user renews it.
@@ -190,6 +191,7 @@ export class DesktopHost {
         }
         else if (this.upstream) {
             const upstream = new WebSocket(`ws://127.0.0.1:${this.upstream.port}/`);
+            const watch = createRfbWatchGate();
             viewer.upstream = upstream;
             viewer.detach = () => upstream.close();
             upstream.on('error', () => {
@@ -204,12 +206,34 @@ export class DesktopHost {
                     return;
                 }
                 const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                watch.observeServer(chunk);
+                if (watch.failed) {
+                    ws.close(1008, 'desktop_protocol_error');
+                    upstream.close();
+                    return;
+                }
                 send(chunk, isBinary);
             });
             upstream.on('close', () => {
                 if (ws.readyState === WebSocket.OPEN)
                     ws.close();
             });
+            ws.on('message', (data, isBinary) => {
+                if (this.generation !== generation)
+                    return;
+                const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                if (viewer.upstream?.readyState !== WebSocket.OPEN)
+                    return;
+                const outgoing = watch.clientBytes(chunk, this.holder === 'human');
+                if (watch.failed) {
+                    ws.close(1008, 'desktop_protocol_error');
+                    upstream.close();
+                    return;
+                }
+                for (const message of outgoing) {
+                    viewer.upstream.send(message, { binary: isBinary });
+                }
+            });
         }
         this.viewers.add(viewer);
         let closed = false;
@@ -223,12 +247,6 @@ export class DesktopHost {
         };
         ws.on('close', close);
         ws.on('error', close);
-        ws.on('message', (data, isBinary) => {
-            if (this.holder !== 'human' || this.generation !== generation)
-                return;
-            if (viewer.upstream?.readyState === WebSocket.OPEN)
-                viewer.upstream.send(data, { binary: isBinary });
-        });
     }
     rejectPlainConnect(response, url) {
         if (this.currentStatus() !== 'ready') {