Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { describe, expect, it } from "vitest";
import {
isDesktopInput,
parseRemoteDesktopRequest,
REMOTE_DESKTOP_CHANNEL,
isDesktopPermission,
remoteDesktopVideoSettingsWire,
isRemoteDesktopChannelRequest,
parseRemoteDesktopChannelRequest,
parseRemoteDesktopChannelReply,
} from "../remoteDesktop";
import { REMOTE_INVOKE_ALLOWLIST, PUSH_FORWARD_ALLOWLIST } from "../allowlist";
describe("remote desktop wire boundary", () => {
it.each([
{ op: "start", displayId: "1" },
{ op: "heartbeat", lease: "a" },
])(
"accepts an optional boolean lock policy on $op without changing legacy requests",
(request) => {
expect(parseRemoteDesktopRequest(request)).toEqual(request);
for (const lockOnExit of [true, false])
expect(parseRemoteDesktopRequest({ ...request, lockOnExit })).toEqual({
...request,
lockOnExit,
});
for (const lockOnExit of ["true", 1, null, {}])
expect(() =>
parseRemoteDesktopRequest({ ...request, lockOnExit }),
).toThrow("INVALID_REQUEST");
},
);
it("preserves legacy stop and accepts only a boolean explicit lock request", () => {
expect(parseRemoteDesktopRequest({ op: "stop", lease: "a" })).toEqual({ op: "stop", lease: "a" });
expect(parseRemoteDesktopRequest({ op: "stop", lease: "a", lockScreen: true })).toEqual({ op: "stop", lease: "a", lockScreen: true });
for (const lockScreen of ["true", 1, null, {}])
expect(() => parseRemoteDesktopRequest({ op: "stop", lease: "a", lockScreen })).toThrow("INVALID_REQUEST");
});
it("accepts old starts and validates the optional recovery flag", () => {
expect(parseRemoteDesktopRequest({ op: "start", displayId: "1" })).toEqual({
op: "start",
displayId: "1",
});
expect(
parseRemoteDesktopRequest({
op: "start",
displayId: "1",
resume: true,
}),
).toEqual({ op: "start", displayId: "1", resume: true });
for (const resume of ["", 1, null])
expect(() =>
parseRemoteDesktopRequest({ op: "start", displayId: "1", resume }),
).toThrow("INVALID_REQUEST");
});
it("carries a 代输入 request id on start, never a window of the viewer's choosing", () => {
expect(parseRemoteDesktopRequest({ op: "start", displayId: "1", handoff: "req_1-a" })).toEqual({
op: "start",
displayId: "1",
handoff: "req_1-a",
});
for (const handoff of ["", "a b", "x".repeat(129), 42, null, { window: 7 }])
expect(() => parseRemoteDesktopRequest({ op: "start", displayId: "1", handoff })).toThrow("INVALID_REQUEST");
});
it("limits permission actions to status and the dedicated guide", () => {
expect(
parseRemoteDesktopRequest({ op: "permissions", action: "guide" }),
).toEqual({ op: "permissions", action: "guide" });
expect(() =>
parseRemoteDesktopRequest({ op: "permissions", action: "openExternal" }),
).toThrow();
expect(isDesktopPermission("accessibility")).toBe(true);
expect(isDesktopPermission("https://example.com")).toBe(false);
expect(isDesktopPermission("fullDiskAccess")).toBe(false);
});
it("adds only a business invoke channel, never a broadcast", () => {
expect(REMOTE_INVOKE_ALLOWLIST.has(REMOTE_DESKTOP_CHANNEL)).toBe(true);
expect(PUSH_FORWARD_ALLOWLIST.has(REMOTE_DESKTOP_CHANNEL)).toBe(false);
});
it.each([
{ kind: "move", x: NaN, y: 0 },
{ kind: "move", x: -1, y: 0 },
{ kind: "button", x: 0, y: 0, button: 5, down: true },
{ kind: "key", code: "shell", down: true },
{ kind: "text", text: "a".repeat(4097) },
{ kind: "scroll", dx: 1, dy: Infinity },
])("rejects malformed input %j", (value) => {
expect(isDesktopInput(value)).toBe(false);
});
it("bounds batches, SDP, and sequence numbers", () => {
expect(() =>
parseRemoteDesktopRequest({
op: "input",
lease: "a",
sequence: -1,
events: [],
}),
).toThrow();
expect(() =>
parseRemoteDesktopRequest({
op: "input",
lease: "a",
sequence: 1,
events: Array(65).fill({ kind: "release" }),
}),
).toThrow();
expect(() =>
parseRemoteDesktopRequest({
op: "offer",
lease: "a",
sdp: "x".repeat(64001),
}),
).toThrow();
});
describe("video quality tiers", () => {
const offer = (settings: unknown) =>
parseRemoteDesktopRequest({ op: "offer", lease: "a", sdp: "s", settings });
it("keeps only the tier, so hosts own the concrete encoder budget", () => {
for (const quality of ["auto", "saver", "hd"] as const)
expect(
offer(remoteDesktopVideoSettingsWire({ fps: 60, quality, audio: true })),
).toMatchObject({
settings: { fps: 60, quality, audio: true },
});
expect(
offer({ fps: 30, quality: "hd", bitrate: 20_000_000, audio: false }),
).toEqual({
op: "offer",
lease: "a",
sdp: "s",
settings: { fps: 30, quality: "hd", audio: false },
});
});
it("maps bitrate-only settings from older viewers onto tiers", () => {
for (const [bitrate, quality] of [
[0, "auto"],
[2_000_000, "saver"],
[8_000_000, "hd"],
[20_000_000, "hd"],
] as const)
expect(offer({ fps: 30, bitrate, audio: false })).toMatchObject({
settings: { fps: 30, quality, audio: false },
});
});
it("sends a legacy bitrate that older hosts accept, also for unknown future tiers", () => {
expect(
[ "auto", "saver", "hd" ].map(
(quality) =>
remoteDesktopVideoSettingsWire({
fps: 30,
quality: quality as "auto" | "saver" | "hd",
audio: false,
}).bitrate,
),
).toEqual([0, 2_000_000, 20_000_000]);
expect(
offer({ fps: 30, quality: "ultra", bitrate: 20_000_000, audio: false }),
).toMatchObject({ settings: { quality: "hd" } });
// Saver only lowers the bitrate; the viewer's frame rate is sent as chosen.
expect(
remoteDesktopVideoSettingsWire({ fps: 60, quality: "saver", audio: false }),
).toEqual({ fps: 60, quality: "saver", audio: false, bitrate: 2_000_000 });
expect(
remoteDesktopVideoSettingsWire({ fps: 60, quality: "auto", audio: false }).fps,
).toBe(60);
});
it.each([
{ fps: 30, audio: false },
{ fps: 30, quality: "ultra", audio: false },
{ fps: 30, bitrate: 5_000_000, audio: false },
{ fps: 24, quality: "auto", audio: false },
{ fps: 30, quality: "auto", audio: "yes" },
null,
])("rejects invalid settings %j", (settings) => {
expect(() => offer(settings)).toThrow("INVALID_REQUEST");
});
});
});
describe("remote desktop channel requests", () => {
it("allows only small lease-scoped control operations", () => {
const allowed = [
{ op: "control", lease: "l", enabled: true },
{ op: "presentation", lease: "l", enabled: false },
{ op: "hostMute", lease: "l", enabled: true },
{ op: "privacyScreen", lease: "l", enabled: true },
{ op: "windowAction", lease: "l", action: "desktop" },
{ op: "displayModes", lease: "l" },
{ op: "clipboardSync", lease: "l", enabled: true },
{ op: "clipboardVersion", lease: "l" },
] as const;
for (const request of allowed)
expect(isRemoteDesktopChannelRequest(request as never)).toBe(true);
for (const request of [
{ op: "capabilities" },
{ op: "start", displayId: "1" },
{ op: "heartbeat", lease: "l" },
{ op: "offer", lease: "l", sdp: "x" },
{ op: "frame", lease: "l" },
{ op: "stop", lease: "l" },
{ op: "resolution", lease: "l", modeId: "1" },
{ op: "viewerDisplay", lease: "l", width: 900, height: 1600 },
{ op: "windowAction", lease: "l", action: "list" },
{ op: "clipboard", lease: "l", action: "copy" },
])
expect(isRemoteDesktopChannelRequest(request as never)).toBe(false);
});
it("parses request envelopes with a bounded id and a validated payload", () => {
const request = { op: "hostMute", lease: "l", enabled: true };
expect(
parseRemoteDesktopChannelRequest({ type: "request", id: "a-1", request }),
).toEqual({ type: "request", id: "a-1", request });
expect(parseRemoteDesktopChannelRequest({ sequence: 1, events: [] })).toBe(
null,
);
for (const id of ["", "a".repeat(65), "has space", 7])
expect(
parseRemoteDesktopChannelRequest({ type: "request", id, request }),
).toBe(null);
expect(() =>
parseRemoteDesktopChannelRequest({
type: "request",
id: "a",
request: { op: "start", displayId: "1" },
}),
).toThrow("INVALID_REQUEST");
expect(() =>
parseRemoteDesktopChannelRequest({
type: "request",
id: "a",
request: { op: "hostMute", lease: "l", enabled: "yes" },
}),
).toThrow();
});
it("parses replies and reduces unknown errors to a stable code", () => {
expect(
parseRemoteDesktopChannelReply({
type: "reply",
id: "a",
ok: true,
result: { controlling: true },
}),
).toEqual({
type: "reply",
id: "a",
ok: true,
result: { controlling: true },
});
expect(
parseRemoteDesktopChannelReply({
type: "reply",
id: "a",
ok: false,
error: "DESKTOP_VIEW_ONLY",
}),
).toEqual({
type: "reply",
id: "a",
ok: false,
error: "DESKTOP_VIEW_ONLY",
});
for (const error of [undefined, "free text", "x".repeat(80), 3])
expect(
parseRemoteDesktopChannelReply({
type: "reply",
id: "a",
ok: false,
error,
}),
).toMatchObject({ ok: false, error: "DESKTOP_REQUEST_FAILED" });
expect(parseRemoteDesktopChannelReply({ type: "cursor" })).toBe(null);
});
});
describe("remote desktop viewerHidden", () => {
it("parses a lease-scoped boolean and stays off the media channel", () => {
for (const hidden of [true, false]) {
const request = { op: "viewerHidden", lease: "l", hidden };
expect(parseRemoteDesktopRequest({ ...request, extra: 1 })).toEqual(request);
expect(isRemoteDesktopChannelRequest(request as never)).toBe(false);
}
for (const hidden of [undefined, "yes", 1])
expect(() => parseRemoteDesktopRequest({ op: "viewerHidden", lease: "l", hidden })).toThrow(
"INVALID_REQUEST",
);
expect(() => parseRemoteDesktopRequest({ op: "viewerHidden", hidden: true })).toThrow(
"INVALID_LEASE",
);
});
});
// Unit: wire compatibility keeps legacy senders unchanged and rejects invalid safety durations.
it.each([{ op: "start", displayId: "1" }, { op: "heartbeat", lease: "a" }])(
"validates the optional idle duration on $op", (request) => {
expect(parseRemoteDesktopRequest(request)).toEqual(request);
for (const idleTimeoutMinutes of [0, 1, 5, 10, 15, 30])
expect(parseRemoteDesktopRequest({ ...request, idleTimeoutMinutes })).toEqual({ ...request, idleTimeoutMinutes });
for (const idleTimeoutMinutes of [-1, 0.5, 2, 60, Infinity, NaN, "5", null, true])
expect(() => parseRemoteDesktopRequest({ ...request, idleTimeoutMinutes })).toThrow("INVALID_REQUEST");
},
);