termdock 1.4.295 → 1.4.297

package/dist/server/agent/collaborationTaskTypes.js

@@ -0,0 +1 @@
+export function taskMemberKey(member) { return `${member.serviceId}:${member.sessionId}`; }

package/dist/server/agent/collaborationTaskWorkspace.js

@@ -0,0 +1,165 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, readFile, writeFile, rename, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+const exec = promisify(execFile);
+const git = async (cwd, args) => (await exec('git', ['-C', cwd, ...args], {
+    timeout: 30_000, maxBuffer: 2 * 1024 * 1024,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_MERGE_AUTOEDIT: 'no' },
+})).stdout.trim();
+const home = path.join(os.homedir(), '.termdock', 'task-workspaces');
+/** Only committed code enters task worktrees; the user's checkout is never reset, cleaned or merged. */
+export async function prepareTaskWorkspace(task, sourceCwd, dependencies, importCommit) {
+    if (!/^[a-f0-9]{32}$/.test(task.id))
+        throw new Error('任务标识无效');
+    const generation = task.events.filter(e => e.kind === 'scheduled').at(-1)?.id;
+    if (!generation || !/^[a-f0-9]{32}$/.test(generation))
+        throw new Error('缺少执行目录准备记录');
+    const repository = await git(sourceCwd, ['rev-parse', '--show-toplevel']);
+    const rootId = task.workflow?.rootTaskId ?? task.id;
+    const goalDir = path.join(home, rootId);
+    await mkdir(goalDir, { recursive: true, mode: 0o700 });
+    // Pin a base per repository and goal. A moved user HEAD cannot change later tasks' starting point.
+    const { createHash } = await import('node:crypto');
+    const common = await realpath(path.resolve(repository, await git(repository, ['rev-parse', '--git-common-dir'])));
+    const baseFile = path.join(goalDir, `${createHash('sha256').update(common).digest('hex').slice(0, 16)}.base`);
+    let base;
+    try {
+        base = (await readFile(baseFile, 'utf8')).trim();
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        base = await git(repository, ['rev-parse', 'HEAD']);
+        try {
+            await writeFile(baseFile, base, { flag: 'wx', mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            base = (await readFile(baseFile, 'utf8')).trim();
+        }
+    }
+    if (!/^[a-f0-9]{40,64}$/.test(base))
+        throw new Error('目标基线无效');
+    const cwd = path.join(goalDir, `${task.id}-${generation.slice(0, 8)}`);
+    const branch = `termdock/task/${task.id}-${generation.slice(0, 8)}`;
+    try {
+        await readFile(path.join(cwd, '.git'), 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        await git(repository, ['worktree', 'add', '-b', branch, cwd, base]);
+    }
+    if (await git(cwd, ['rev-parse', '--show-toplevel']) !== cwd || await git(cwd, ['branch', '--show-current']) !== branch)
+        throw new Error('独立目录与任务分支不匹配，保留现场等待处理');
+    const readyFile = path.join(goalDir, `${task.id}-${generation.slice(0, 8)}.ready`);
+    let ready = false;
+    try {
+        ready = (await readFile(readyFile, 'utf8')) === generation;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    if (!ready) {
+        // A failed merge is deliberately left in this task's worktree for a member to resolve.
+        if (await git(cwd, ['status', '--porcelain']))
+            throw new Error(`依赖集成需要处理，现场保留在 ${cwd}；请协调者安排解决冲突后继续`);
+        for (const dependency of dependencies) {
+            const artifact = dependency.artifacts.find(a => a.id === dependency.acceptedArtifactId);
+            const commit = artifact?.evidence?.commit;
+            if (!commit || !/^[a-f0-9]{40,64}$/.test(commit))
+                throw new Error(`依赖「${dependency.title}」缺少已评审提交，请补充交付`);
+            try {
+                await git(cwd, ['cat-file', '-e', `${commit}^{commit}`]);
+            }
+            catch {
+                if (!importCommit)
+                    throw new Error(`依赖「${dependency.title}」的提交在此仓库不可用，请协调者先同步提交`);
+                await importCommit(dependency, cwd);
+                await git(cwd, ['cat-file', '-e', `${commit}^{commit}`]);
+            }
+            await git(cwd, ['-c', 'user.name=Termdock', '-c', 'user.email=tasks@termdock.local', 'merge', '--no-edit', commit]);
+        }
+        const temp = `${readyFile}.${process.pid}.tmp`;
+        await writeFile(temp, generation, { mode: 0o600 });
+        await rename(temp, readyFile);
+    }
+    return { cwd, repository, branch, base };
+}
+export async function captureTaskCommit(workspace) {
+    if (!(await realpath(workspace.cwd)).startsWith(`${await realpath(home)}${path.sep}`) || await git(workspace.cwd, ['branch', '--show-current']) !== workspace.branch)
+        throw new Error('交付目录与任务分支不匹配');
+    if (await git(workspace.cwd, ['status', '--porcelain']))
+        throw new Error('独立目录还有未提交改动，请先提交再报告完成；不会自动暂存或提交');
+    const commit = await git(workspace.cwd, ['rev-parse', 'HEAD']);
+    return { commit, branch: workspace.branch, cwd: workspace.cwd, base: workspace.base };
+}
+async function assertManagedWorkspace(workspace) {
+    const relative = path.relative(home, workspace.cwd);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)
+        || !/^termdock\/task\/[a-f0-9]{32}-[a-f0-9]{8}$/.test(workspace.branch))
+        throw new Error('目录不是 Termdock 独立执行工作区');
+    const actual = await realpath(workspace.cwd);
+    if (actual !== path.resolve(workspace.cwd) || !actual.startsWith(`${await realpath(home)}${path.sep}`)
+        || await git(actual, ['rev-parse', '--show-toplevel']) !== actual
+        || await git(actual, ['branch', '--show-current']) !== workspace.branch)
+        throw new Error('执行目录或分支发生变化，现场已保留');
+    const common = async (cwd) => realpath(path.resolve(cwd, await git(cwd, ['rev-parse', '--git-common-dir'])));
+    if (await common(actual) !== await common(workspace.repository))
+        throw new Error('执行目录不属于原仓库，现场已保留');
+}
+/** Remove only a verified, clean worktree. Keep its branch and all Git commits. */
+export async function archiveTaskWorkspace(workspace) {
+    try {
+        await assertManagedWorkspace(workspace);
+        const commit = await git(workspace.cwd, ['rev-parse', 'HEAD']);
+        if (await git(workspace.cwd, ['status', '--porcelain']) || await git(workspace.cwd, ['ls-files', '--others', '--ignored', '--exclude-standard'])) {
+            return { state: 'retained', reason: '目录含未提交或忽略的文件，已保留现场', commit };
+        }
+        await git(workspace.repository, ['worktree', 'remove', workspace.cwd]);
+        return { state: 'removed', commit };
+    }
+    catch (error) {
+        return { state: 'retained', reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function snapshotTaskWorkspace(workspace) {
+    await assertManagedWorkspace(workspace);
+    return git(workspace.cwd, ['rev-parse', 'HEAD']);
+}
+export async function restoreTaskWorkspace(workspace, cleanup) {
+    if (cleanup.state !== 'removed') {
+        try {
+            await assertManagedWorkspace(workspace);
+            return;
+        }
+        catch (error) {
+            if (cleanup.state !== 'pending' || error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    const relative = path.relative(home, workspace.cwd);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)
+        || !/^termdock\/task\/[a-f0-9]{32}-[a-f0-9]{8}$/.test(workspace.branch) || !cleanup.commit)
+        throw new Error('工作区恢复记录无效');
+    try {
+        await stat(workspace.cwd);
+        await assertManagedWorkspace(workspace);
+        return;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    if (await git(workspace.repository, ['rev-parse', workspace.branch]) !== cleanup.commit)
+        throw new Error('归档分支已有变化，请核对后再恢复；不会重置分支');
+    await mkdir(path.dirname(workspace.cwd), { recursive: true, mode: 0o700 });
+    if (!(await realpath(path.dirname(workspace.cwd))).startsWith(`${await realpath(home)}${path.sep}`))
+        throw new Error('工作区父目录发生变化');
+    await git(workspace.repository, ['worktree', 'add', workspace.cwd, workspace.branch]);
+    await assertManagedWorkspace(workspace);
+}

package/dist/server/agent/collaborationTeam.js

@@ -0,0 +1,16 @@
+/** Provision only missing roles. Persist each member before proceeding so a
+ * failed launch, retry or server restart cannot create another full team. */
+export async function ensureTeam(options) {
+    const ids = [];
+    const labels = [`自动协调者 (${options.agentSlug})`, `自动执行与评审 (${options.agentSlug})`];
+    for (const role of labels) {
+        const members = options.members();
+        const reserved = members.find(member => member.role?.startsWith(role.split(' (')[0]));
+        if (reserved && (reserved.role !== role || reserved.cwd !== options.cwd)) {
+            throw new Error('本组已有自动配置的成员，请使用原 Agent 和目录，或在成员设置中移出后重新配置');
+        }
+        const existing = reserved ?? members.find(member => !ids.includes(member.id) && member.agentSlug === options.agentSlug && member.cwd === options.cwd);
+        ids.push(existing?.id ?? await options.spawn(role));
+    }
+    return { coordinatorSessionId: ids[0], reviewerSessionIds: [ids[1]] };
+}

package/dist/server/agent/executionArchives.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { normalizePersistedAgentResumeInfo } from './resumePersistence.js';
+/** Explicit archives are durable records, independent of the recent-history cap. */
+export class ExecutionArchiveStore {
+    file;
+    entries;
+    constructor(file) {
+        this.file = file;
+        try {
+            const document = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (document.version !== 1 || !Array.isArray(document.entries))
+                throw new Error('执行归档文件格式无效');
+            this.entries = document.entries.map((entry) => {
+                const agent = normalizePersistedAgentResumeInfo(entry.agent);
+                if (!agent || !entry.sessionId || !entry.workspace?.cwd || !Array.isArray(entry.groups) || !Array.isArray(entry.taskIds))
+                    throw new Error('执行归档记录无效');
+                return { ...entry, agent };
+            });
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            this.entries = [];
+        }
+    }
+    list() { return structuredClone(this.entries); }
+    get(id) { return this.list().find(entry => entry.sessionId === id); }
+    save(entry) {
+        if (!normalizePersistedAgentResumeInfo(entry.agent))
+            throw new Error('没有可恢复的 Agent 原生会话 ID，终端已保留');
+        const entries = [structuredClone(entry), ...this.entries.filter(item => item.sessionId !== entry.sessionId)];
+        fs.mkdirSync(path.dirname(this.file), { recursive: true, mode: 0o700 });
+        const temporary = `${this.file}.${process.pid}.tmp`;
+        fs.writeFileSync(temporary, JSON.stringify({ version: 1, entries }), { mode: 0o600 });
+        fs.renameSync(temporary, this.file);
+        this.entries = entries;
+        return structuredClone(entry);
+    }
+}
+export function completedExecution(tasks, serviceId, sessionId) {
+    const matches = (member) => member?.serviceId === serviceId && member.sessionId === sessionId;
+    if (tasks.some(task => matches(task.coordinator) || task.workflow?.reviewers.some(matches)
+        || task.status === 'open' && (matches(task.attempts.find(a => a.id === task.activeAttemptId)?.assignee) || matches(task.scheduledAssignee)))) {
+        throw new Error('此会话仍承担协作工作，不能归档；请完成当前任务后再操作');
+    }
+    const completed = tasks.filter(task => task.status !== 'open' && task.workspace && task.workflow?.kind === 'step' && task.workflow.isolated
+        && matches(task.attempts.find(a => a.id === task.activeAttemptId)?.assignee));
+    if (!completed.length)
+        throw new Error('此会话没有已完成的独立执行任务，终端已保留');
+    return completed;
+}

package/dist/server/entry.js

@@ -1,7 +1,8 @@
 import { CollaborationService } from './agent/collaborationService.js';
 import { X509Certificate } from 'node:crypto';
 import { CollaborationPeerTransport, connectCollaborationRpc } from './agent/collaborationPeerTransport.js';
-import { collaborationStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions } from './routes/terminal.js';
+import { collaborationStore, collaborationTaskStore, deliverPeerCollaboration, collaborationLocalActivity, collaborationDirectorySessions, prepareCollaborationTaskWorker } from './routes/terminal.js';
+import { CollaborationTaskService } from './agent/collaborationTaskService.js';
 import { setPushTargetPeerId } from './notifications/pushService.js';
 import { desktopDirectTargets } from './federation/desktopTargets.js';
 import { createOpenAccessRouter } from './federation/openAccess.js';
@@ -31,6 +32,7 @@ import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 import terminalRoutes, { handleTerminalWebSocket, handleControlWebSocket, resolveStableFederationSessionId } from './routes/terminal.js';
 import androidRoutes, { handleAndroidWebSocket } from './routes/android.js';
+import computerRoutes, { handleComputerWebSocket, stopComputerBridges } from './routes/computer.js';
 import { exitWithStartupFailure } from './utils/startupFailure.js';
 import { androidRecordings } from './android/recording.js';
 import { stopAllScrcpySessions } from './android/scrcpy.js';
@@ -348,6 +350,9 @@ export function createApp(options = {}) {
     app.use('/api/android', requireAuth({ bypass: isTrustedLocalCliRequest }));
     app.use('/api/android', csrfProtection.verifyMiddleware({ bypass: isTrustedLocalCliRequest }));
     app.use('/api/android', androidRoutes);
+    app.use('/api/computer', requireAuth({ bypass: isTrustedLocalCliRequest }));
+    app.use('/api/computer', csrfProtection.verifyMiddleware({ bypass: isTrustedLocalCliRequest }));
+    app.use('/api/computer', computerRoutes);
     if (fs.existsSync(bundledClientIndexPath)) {
         const clientPath = pinBundledRuntimeClientDist(bundledClientDistPath);
         const compression = createStaticCompressionMiddleware(clientPath);
@@ -499,8 +504,9 @@ export function startServer(options = {}) {
         target.close(); });
     server.once('close', () => relayRouter.close());
     server.once('close', () => { void stopAllScrcpySessions(); void androidRecordings.stopAll(); });
+    server.once('close', stopComputerBridges);
     const federation = createFederationRuntime(app, path.join(homedir(), '.termdock', 'federation'), {
-        terminal: handleTerminalWebSocket, control: handleControlWebSocket, android: handleAndroidWebSocket,
+        terminal: handleTerminalWebSocket, control: handleControlWebSocket, android: handleAndroidWebSocket, computer: handleComputerWebSocket,
     }, {
         resolveSessionId: resolveStableFederationSessionId,
         collaborationConnected: (subjectId, rpc) => {
@@ -616,11 +622,20 @@ export function startServer(options = {}) {
         collaborationService = new CollaborationService({ file: path.join(homedir(), '.termdock', 'federation', 'collaboration-services.json'),
             store: collaborationStore, transport: collaborationTransport, node: () => app.locals.collaborationNode,
             sessions: collaborationDirectorySessions, reverse: reverseCollaboration, connect: connectPeer,
+            tasks: {
+                receive: (peer, packet) => app.locals.collaborationTasks.receive(peer, packet),
+                heads: ids => app.locals.collaborationTasks?.heads(ids) ?? [],
+                sync: (peer, heads) => app.locals.collaborationTasks.sync(peer, heads),
+            },
             deviceScope: device => runtime.store.listEffective({ subjectId: device, serviceId: runtime.serviceId })
                 .filter(grant => grant.scope.kind === 'sessions' && grant.actions.includes('session.input'))
                 .flatMap(grant => grant.scope.kind === 'sessions' ? grant.scope.sessionIds : []),
             pairConnect: peer => connectCollaborationRpc(runtime.identity, peer) });
         app.locals.collaborationService = collaborationService;
+        const collaborationTasks = new CollaborationTaskService(collaborationTaskStore, collaborationStore, collaborationService, deliverPeerCollaboration, (task, template, dependencies) => prepareCollaborationTaskWorker(task, template, dependencies, collaborationService, (taskId, dependencyId, offset) => collaborationTasks.dependencyChunk(taskId, dependencyId, offset)));
+        app.locals.collaborationTasks = collaborationTasks;
+        collaborationTasks.start();
+        server.once('close', () => collaborationTasks.close());
         collaborationService.start();
         server.once('close', () => collaborationService?.close());
         collaborationTransport.start();

package/dist/server/federation/runtime.js

@@ -252,8 +252,8 @@ export async function createFederationRuntime(app, directory, handlers, options
                 }
             }
             revokeTimer = setInterval(() => {
-                for (const { socket: logical, sessionId, android } of sockets.values()) {
-                    if (android) {
+                for (const { socket: logical, sessionId, android, computer } of sockets.values()) {
+                    if (android || computer) {
                         if (!full(subjectId))
                             logical.close(4003, 'Authorization revoked');
                         continue;
@@ -297,7 +297,12 @@ export async function createFederationRuntime(app, directory, handlers, options
                     else if (packet.type === 'collaboration-service') {
                         if (!options.collaborationService)
                             throw new Error('COLLABORATION_UPGRADE_REQUIRED');
-                        send({ type: 'result', id: packet.id, ...options.collaborationService(subjectId, packet) });
+                        // Task preparation may use the same channel for a directory request; do not block its reader.
+                        void Promise.resolve(options.collaborationService(subjectId, packet)).then(result => send({ type: 'result', id: packet.id, ...result }))
+                            .catch(error => { try {
+                            send({ type: 'error', id: packet.id, error: error instanceof Error ? error.message : 'REQUEST_FAILED' });
+                        }
+                        catch { /* Connection closed. */ } });
                     }
                     else if (packet.type === 'collaboration-scoped-peer') {
                         if (!options.registerScopedCollaborationPeer)
@@ -564,18 +569,20 @@ export async function createFederationRuntime(app, directory, handlers, options
                         const url = new URL(packet.path, 'http://inner');
                         const match = /^\/api\/terminal\/([^/%]+)\/ws$/.exec(url.pathname);
                         const androidMatch = /^\/api\/android\/([^/%]+)\/ws$/.exec(url.pathname);
+                        const computer = url.pathname === '/api/computer/ws';
                         if (match)
                             check('session.view', match[1]);
                         else if (url.pathname === '/api/control/ws')
                             check('service.view');
-                        else if (androidMatch) {
+                        else if (androidMatch || computer) {
                             if (!full(subjectId))
                                 throw new Error('API_NOT_ALLOWED');
                         }
                         else
                             throw new Error('API_NOT_ALLOWED');
-                        const logical = new LogicalSocket(channel, packet.id, () => androidMatch ? full(subjectId) : allowed(subjectId, match ? 'session.view' : 'service.view', match?.[1]));
-                        sockets.set(packet.id, { socket: logical, sessionId: match?.[1], android: Boolean(androidMatch) });
+                        const logical = new LogicalSocket(channel, packet.id, () => (androidMatch || computer) ? full(subjectId) : allowed(subjectId, match ? 'session.view' : 'service.view', match?.[1]));
+                        sockets.set(packet.id, { socket: logical, sessionId: match?.[1], android: Boolean(androidMatch), computer,
+                            computerProtocol: computer ? url.searchParams.get('protocol') ?? 'vnc' : undefined });
                         logical.once('close', () => sockets.delete(packet.id));
                         send({ type: 'ws-ready', id: packet.id });
                         if (match)
@@ -593,6 +600,15 @@ export async function createFederationRuntime(app, directory, handlers, options
                                 maxFps: Number(url.searchParams.get('max_fps')) || undefined,
                             });
                         }
+                        else if (computer) {
+                            if (!handlers.computer) {
+                                logical.close(4403, 'API_NOT_ALLOWED');
+                                continue;
+                            }
+                            handlers.computer(logical, url.searchParams.get('host') ?? '', {
+                                protocol: url.searchParams.get('protocol') ?? undefined, port: url.searchParams.get('port') ?? undefined,
+                            });
+                        }
                         else
                             handlers.control(logical, randomUUID());
                     }
@@ -601,7 +617,14 @@ export async function createFederationRuntime(app, directory, handlers, options
                         if (!item || typeof packet.data !== 'string')
                             throw new Error('INVALID_STREAM');
                         const data = JSON.parse(packet.data);
-                        if (item.android) {
+                        if (item.computer) {
+                            if (!full(subjectId))
+                                throw new Error('AUTHORIZATION_DENIED');
+                            const types = item.computerProtocol === 'rdp' ? ['start', 'instruction', 'ack'] : ['data', 'ack'];
+                            if (!types.includes(data?.type))
+                                throw new Error('ACTION_NOT_ALLOWED');
+                        }
+                        else if (item.android) {
                             if (!full(subjectId))
                                 throw new Error('AUTHORIZATION_DENIED');
                             if (!['control', 'ack', 'ping', 'bitrate'].includes(data?.type))

package/dist/server/routes/computer.js

@@ -0,0 +1,198 @@
+import { Router } from 'express';
+import { isDeepStrictEqual } from 'node:util';
+import { hostname } from 'node:os';
+import { Socket } from 'node:net';
+import { resolveComputerHost } from './computerTarget.js';
+import { handleRdpWebSocket, rdpBackendAvailable, stopRdpBridges } from './rdp.js';
+import { computerLoginKey, computerPreferences } from '../shared/computerPreferences.js';
+import { loadSettings, updateSettings } from '../utils/settings.js';
+import { ComputerCredentialStore } from '../utils/computerCredentials.js';
+export function createComputerRouter(read = loadSettings, update = updateSettings, credentials = new ComputerCredentialStore()) {
+    const router = Router();
+    router.get('/status', async (_req, res) => res.json({ platform: process.platform, hostname: hostname(), rdpAvailable: await rdpBackendAvailable() }));
+    router.get('/preferences', (_req, res) => {
+        try {
+            const saved = read().computerControl;
+            const preferences = computerPreferences(saved, process.platform);
+            let credentialKeys = [], credentialError = false;
+            try {
+                credentialKeys = [preferences.local, preferences.remote].filter(profile => profile.rememberLogin && credentials.has(profile)).map(computerLoginKey);
+            }
+            catch {
+                credentialError = true;
+            }
+            res.set('Cache-Control', 'no-store').json({ preferences, configured: Boolean(saved), credentialKeys, credentialError });
+        }
+        catch {
+            res.status(500).json({ error: 'COMPUTER_PREFERENCES_READ_FAILED' });
+        }
+    });
+    // The full-service encrypted API boundary applies to every credential route.
+    router.post('/credentials/:action', (req, res) => {
+        res.set('Cache-Control', 'no-store');
+        try {
+            const { profile, password } = req.body ?? {};
+            const preferences = computerPreferences(read().computerControl, process.platform);
+            const matched = [preferences.local, preferences.remote].find(value => isDeepStrictEqual(value, profile));
+            const action = req.params.action;
+            const allowedKeys = action === 'save' ? ['profile', 'password'] : ['profile'];
+            if (!matched || !['save', 'use', 'forget'].includes(action) || Object.keys(req.body).some(key => !allowedKeys.includes(key))) {
+                res.status(400).json({ error: 'INVALID_COMPUTER_CREDENTIALS' });
+                return;
+            }
+            if (action === 'forget') {
+                credentials.forget(matched);
+                res.json({ saved: false });
+                return;
+            }
+            if (!matched.rememberLogin) {
+                res.status(400).json({ error: 'COMPUTER_LOGIN_NOT_REMEMBERED' });
+                return;
+            }
+            if (action === 'save') {
+                if (typeof password !== 'string' || !password || password.length > 1024 || password.includes('\0')) {
+                    res.status(400).json({ error: 'INVALID_COMPUTER_CREDENTIALS' });
+                    return;
+                }
+                credentials.save(matched, password);
+                res.json({ saved: true });
+                return;
+            }
+            const secret = credentials.get(matched);
+            if (!secret) {
+                res.status(404).json({ error: 'COMPUTER_CREDENTIALS_MISSING' });
+                return;
+            }
+            // Only the authenticated service page receives it, in memory, over Noise.
+            res.json({ password: secret });
+        }
+        catch {
+            res.status(500).json({ error: 'COMPUTER_CREDENTIALS_FAILED' });
+        }
+    });
+    router.put('/preferences', (req, res) => {
+        const preferences = computerPreferences(req.body, process.platform);
+        // Strict projection prevents credentials and unknown fields entering settings.
+        if (!req.body || !isDeepStrictEqual(preferences, req.body)) {
+            res.status(400).json({ error: 'INVALID_COMPUTER_PREFERENCES' });
+            return;
+        }
+        try {
+            update((settings) => { settings.computerControl = preferences; });
+            res.json({ preferences });
+        }
+        catch {
+            res.status(500).json({ error: 'COMPUTER_PREFERENCES_WRITE_FAILED' });
+        }
+    });
+    return router;
+}
+export default createComputerRouter();
+const bridges = new Set();
+export function stopComputerBridges() {
+    stopRdpBridges();
+    for (const bridge of bridges)
+        bridge.destroy();
+    bridges.clear();
+}
+/** RFB bytes are base64 records inside the existing authenticated Noise tunnel.
+ * The eight-record receive window applies TCP backpressure without dropping bytes. */
+export function handleComputerWebSocket(socket, host, options) {
+    if (options?.protocol === 'rdp') {
+        handleRdpWebSocket(socket, host, Number(options.port ?? 3389));
+        return;
+    }
+    if (options?.protocol && options.protocol !== 'vnc') {
+        socket.close(4400, 'COMPUTER_INVALID_PROTOCOL');
+        return;
+    }
+    let closed = false;
+    let tcp;
+    let sent = 0;
+    let acked = 0;
+    let lastAckAt = Date.now();
+    let connected = false;
+    const finish = (code = 1000, reason = '') => {
+        if (closed)
+            return;
+        closed = true;
+        clearTimeout(connectTimer);
+        clearInterval(flowTimer);
+        if (tcp) {
+            bridges.delete(tcp);
+            tcp.destroy();
+        }
+        socket.close(code, reason);
+    };
+    const connectTimer = setTimeout(() => finish(4408, 'COMPUTER_CONNECT_TIMEOUT'), 10_000);
+    const flowTimer = setInterval(() => {
+        if (sent > acked && Date.now() - lastAckAt > 30_000)
+            finish(4408, 'COMPUTER_STREAM_TIMEOUT');
+    }, 5000);
+    const pump = () => {
+        if (closed || !tcp)
+            return;
+        while (sent - acked < 8 && tcp.readableLength > 0) {
+            const bytes = tcp.read(Math.min(tcp.readableLength, 32 * 1024));
+            if (!bytes)
+                break;
+            if (sent === acked)
+                lastAckAt = Date.now();
+            socket.send(JSON.stringify({ type: 'data', seq: ++sent, data: bytes.toString('base64') }));
+            if (closed)
+                break;
+        }
+    };
+    socket.on('close', () => finish());
+    socket.on('error', () => finish());
+    socket.on('message', raw => {
+        if (closed)
+            return;
+        try {
+            const message = JSON.parse(raw.toString());
+            if (message.type === 'ack') {
+                if (!Number.isSafeInteger(message.seq) || message.seq <= acked || message.seq > sent)
+                    throw new Error('INVALID_ACK');
+                acked = message.seq;
+                lastAckAt = Date.now();
+                pump();
+            }
+            else if (message.type === 'data') {
+                if (!connected || !tcp || typeof message.data !== 'string' || message.data.length > 88_000
+                    || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(message.data))
+                    throw new Error('INVALID_DATA');
+                const bytes = Buffer.from(message.data, 'base64');
+                if (!bytes.length || bytes.length > 64 * 1024 || tcp.writableLength + bytes.length > 1024 * 1024)
+                    throw new Error('INPUT_LIMIT');
+                tcp.write(bytes);
+            }
+            else
+                throw new Error('INVALID_MESSAGE');
+        }
+        catch {
+            finish(4400, 'COMPUTER_INVALID_MESSAGE');
+        }
+    });
+    void (async () => {
+        try {
+            const address = await resolveComputerHost(host);
+            if (closed)
+                return;
+            tcp = new Socket();
+            bridges.add(tcp);
+            tcp.setNoDelay(true);
+            tcp.on('readable', pump);
+            tcp.on('connect', () => { connected = true; clearTimeout(connectTimer); });
+            tcp.on('end', () => finish(1000, 'COMPUTER_DISCONNECTED'));
+            tcp.on('close', () => finish(1000, 'COMPUTER_DISCONNECTED'));
+            tcp.on('error', error => {
+                const code = error.code;
+                finish(4502, code === 'ECONNREFUSED' ? 'COMPUTER_SCREEN_SHARING_OFF' : 'COMPUTER_UNREACHABLE');
+            });
+            tcp.connect({ host: address.address, family: address.family, port: 5900 });
+        }
+        catch (reason) {
+            finish(4502, reason instanceof Error && /^COMPUTER_(?:INVALID_HOST|PRIVATE_HOST_ONLY)$/.test(reason.message) ? reason.message : 'COMPUTER_UNREACHABLE');
+        }
+    })();
+}

package/dist/server/routes/computerTarget.js

@@ -0,0 +1,23 @@
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+export function privateComputerAddress(address) {
+    if (isIP(address) === 4) {
+        const [a, b] = address.split('.').map(Number);
+        return a === 127 || a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168);
+    }
+    const value = address.toLowerCase();
+    if (value.startsWith('::ffff:'))
+        return privateComputerAddress(value.slice(7));
+    return isIP(value) === 6 && (value === '::1' || value.startsWith('fc') || value.startsWith('fd'));
+}
+/** Resolve once, reject mixed public/private DNS answers, and dial the pinned IP. */
+export async function resolveComputerHost(host) {
+    host = host.trim();
+    if (!host || host.length > 253 || (!isIP(host) && !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host))) {
+        throw new Error('COMPUTER_INVALID_HOST');
+    }
+    const addresses = await lookup(host, { all: true });
+    if (!addresses.length || addresses.some(item => !privateComputerAddress(item.address)))
+        throw new Error('COMPUTER_PRIVATE_HOST_ONLY');
+    return addresses[0];
+}

package/dist/server/routes/guacamoleProtocol.js

@@ -0,0 +1,55 @@
+export function guacamoleInstruction(...values) {
+    return values.map(value => `${Array.from(value).length}.${value}`).join(',') + ';';
+}
+/** Incremental UTF-8-decoded Guacamole parser. Lengths count Unicode code points. */
+export class GuacamoleParser {
+    instruction;
+    digits = '';
+    remaining = 0;
+    value = '';
+    values = [];
+    phase = 'length';
+    size = 0;
+    constructor(instruction) {
+        this.instruction = instruction;
+    }
+    receive(chunk) {
+        for (const char of chunk) {
+            if (++this.size > 2 * 1024 * 1024)
+                throw new Error('GUAC_INSTRUCTION_LIMIT');
+            if (this.phase === 'length') {
+                if (/^[0-9]$/.test(char) && this.digits.length < 7)
+                    this.digits += char;
+                else if (char === '.' && this.digits) {
+                    this.remaining = Number(this.digits);
+                    this.digits = '';
+                    if (this.remaining > 1024 * 1024)
+                        throw new Error('GUAC_ELEMENT_LIMIT');
+                    this.phase = this.remaining ? 'value' : 'separator';
+                }
+                else
+                    throw new Error('GUAC_INVALID_LENGTH');
+            }
+            else if (this.phase === 'value') {
+                this.value += char;
+                if (--this.remaining === 0)
+                    this.phase = 'separator';
+            }
+            else {
+                if (char !== ',' && char !== ';')
+                    throw new Error('GUAC_INVALID_SEPARATOR');
+                this.values.push(this.value);
+                this.value = '';
+                this.phase = 'length';
+                if (this.values.length > 256)
+                    throw new Error('GUAC_ARGUMENT_LIMIT');
+                if (char === ';') {
+                    const values = this.values;
+                    this.values = [];
+                    this.size = 0;
+                    this.instruction(values);
+                }
+            }
+        }
+    }
+}