officerdev/platform
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

the platform stops knowing what VNC is

Browse Source 
Desktop is a plugin as of today, and this is the half that leaves. sidecar/vnc/, api/desktop/ and
apps/Desktop/ are gone from src/, along with the vocabulary that was the real problem.

sidecar/protocol.ts had a VNC section: vnc:start, vnc:ensure-password, vnc:stop, four reply variants
and two types. sidecar-registry.ts had startVnc, ensureVncPassword, stopVnc, isVncConnected. Four
functions and a dozen message types in the platform, describing a feature that is not the platform's —
the rule CLAUDE.md states most plainly, and its clearest breach.

What replaced them is generic. sendSidecarCommand(kind, cmd) and isSidecarConnected(kind) know that a
command has a type and an id and that a reply carries the same id. A plugin's sidecar speaks whatever
it likes through them and nothing here has to be edited when it adds a message.

The desktop PERMISSION leaves too, and that is the interesting part: it was kind: 'execution', a kind
a plugin permission cannot have and never will, because a permission nobody can delegate is a
contradiction. The plugin expresses the same refusal as ownerOnly: ['/'] — every path under it denied
to anyone but the owner. Verified: /api/desktop, /api/desktop/vnc-password and a path that does not
exist all resolve owner-only. registry.test.ts records the round trip rather than just dropping the
key from its list.

Also gone: the app store's `vnc` entry, which would have offered an older second way to install the
same thing against a process PM2 no longer has, and four commented-out mounts left from 2026-08-13.

The disconnect-scope test used startVnc as its stand-in for "another sidecar's long-running request".
It now uses the generic door, which is the better instrument — that file is about the blast radius of
a disconnect and never had anything to do with VNC.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
pastilhas
2026-08-21 00:42:19 +00:00
co-authored by Claude Opus 5
parent b1a2d67b76
commit fcdbf02649
20 changed files with 67 additions and 929 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/servers/api/desktop/rest.ts
-33
View File
@@ -1,33 +0,0 @@
import { createRouter } from '../../create-router';
import * as sidecar from '@@/sidecar-registry';
export const desktopRouter = createRouter();
// The desktop UI asks for the password before it can open the WebSocket — and that WebSocket is what
// starts the VNC session. So this cannot wait for a session to exist: on a fresh install nothing has
// ever written the password, and answering "not configured" deadlocked the page permanently.
//
// Officer does not read the password file itself. It lives in the owner's ~/.vnc, next to the rfbauth
// file x11vnc authenticates against, and the sidecar is the process that writes both — so it is the
// process that answers for them too. `vnc:ensure-password` is idempotent: it returns the existing
// pair when both files are already there, and provisions them when they are not.
desktopRouter.get('/vnc-password', async (ctx) => {
const user = ctx.get('user');
if (!sidecar.isVncConnected()) {
return ctx.json({ error: 'VNC sidecar is not connected' }, 503);
}
try {
const password = await sidecar.ensureVncPassword(user.email);
return ctx.json({ password });
} catch (err) {
const message = err instanceof Error ? err.message : 'Could not provision the VNC password';
console.error('[desktop] VNC password provisioning failed:', message);
return ctx.json({ error: message }, 500);
}
});
// GET /vnc-status is gone. It was never called — DesktopView asks only for /vnc-password — and it was
// the sole reason the `vnc:status` command existed on the sidecar wire protocol at all. Noted as dead
// by docs/sidecar-audit-2026-07.md months ago.
src/servers/api/desktop/websocket.ts
-122
View File
@@ -1,122 +0,0 @@
import type { ServerWebSocket } from 'bun';
import type { Socket } from 'bun';
import * as sidecar from '@@/sidecar-registry';
type WSData = { userId: number; email: string; username: string; sessionId?: string };
type VncSession = {
tcpSocket: Socket<{ ws: ServerWebSocket<WSData> }> | null;
pendingMessages: Buffer[];
};
const sessions = new Map<ServerWebSocket<WSData>, VncSession>();
export const desktopWebsocket = {
async open(ws: ServerWebSocket<WSData>) {
const session: VncSession = { tcpSocket: null, pendingMessages: [] };
sessions.set(ws, session);
let port: number;
try {
const result = await sidecar.startVnc({
email: ws.data.email,
username: ws.data.username,
});
port = result.port;
} catch (err) {
const message = err instanceof Error ? err.message : 'Failed to start VNC session';
console.error('[desktop] VNC start failed:', message);
sessions.delete(ws);
ws.close(4004, 'VNC server unavailable');
return;
}
try {
const tcpSocket = await Bun.connect({
hostname: '127.0.0.1',
port,
socket: {
data(_socket, data) {
try {
ws.sendBinary(Buffer.from(data));
} catch {
// ws already closed
}
},
close() {
sessions.delete(ws);
try {
ws.close();
} catch {
/* ignore */
}
},
error(_socket, err) {
console.error('[desktop] TCP error:', err.message);
sessions.delete(ws);
try {
ws.close();
} catch {
/* ignore */
}
},
connectError(_socket, err) {
console.error('[desktop] TCP connect error:', err.message);
sessions.delete(ws);
try {
ws.close(4004, 'VNC server unavailable');
} catch {
/* ignore */
}
},
open(socket) {
for (const msg of session.pendingMessages) {
socket.write(msg);
}
session.pendingMessages = [];
},
},
data: { ws },
});
session.tcpSocket = tcpSocket;
} catch (err) {
const message = err instanceof Error ? err.message : 'Failed to connect to VNC server';
console.error('[desktop] VNC connect failed:', message);
sessions.delete(ws);
ws.close(4004, 'VNC server unavailable');
}
},
message(ws: ServerWebSocket<WSData>, raw: string | Buffer) {
const session = sessions.get(ws);
if (!session) return;
const data = typeof raw === 'string' ? Buffer.from(raw) : Buffer.from(raw);
if (!session.tcpSocket) {
session.pendingMessages.push(data);
return;
}
try {
session.tcpSocket.write(data);
} catch {
// ignore
}
},
close(ws: ServerWebSocket<WSData>) {
const session = sessions.get(ws);
if (session?.tcpSocket) {
try {
session.tcpSocket.end();
} catch {
// ignore
}
}
sessions.delete(ws);
},
drain() {},
};