Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { it, expect, vi } from "vitest";
import {
RemoteDesktopViewerSession,
type DesktopViewerRequest,
} from "../remoteDesktopViewerSession";
import type { RemoteDesktopRequest } from "../remoteDesktop";
const caps = {
version: 1,
enabled: true,
canControl: true,
automaticReconnect: true,
connectionTakeover: true,
displays: [{ id: "screen" }],
};
function fixture() {
const request = vi.fn(async (r: RemoteDesktopRequest): Promise<unknown> =>
r.op === "capabilities"
? caps
: r.op === "start"
? { lease: "lease", display: { id: "screen" }, controlling: false }
: { controlling: true },
);
return {
request,
session: new RemoteDesktopViewerSession(request as DesktopViewerRequest),
};
}
it("uses the same peer protocol for a normal start, explicit takeover and an older host", async () => {
const f = fixture();
await f.session.connect({ isCurrent: () => true, takeover: true });
expect(f.request.mock.calls[1][0]).toEqual({
op: "start",
displayId: "screen",
takeover: true,
});
await f.session.stop();
f.request.mockResolvedValueOnce({ ...caps, automaticReconnect: false });
await expect(
f.session.connect({ isCurrent: () => true, resume: true }),
).rejects.toThrow("CHANNEL_NOT_ALLOWED");
});
it("a heartbeat sent before a control transition cannot overwrite the confirmed result", async () => {
const f = fixture();
await f.session.connect({ isCurrent: () => true });
let resolve!: (value: unknown) => void;
f.request.mockImplementationOnce(
() =>
new Promise((r) => {
resolve = r;
}),
);
const heartbeat = f.session.heartbeat();
await f.session.control(true);
resolve({ controlling: false });
expect(await heartbeat).toEqual({ controlling: true });
});
it("an uncertain release blocks takeover until a heartbeat reconciles and releases host input", async () => {
const f = fixture();
await f.session.connect({ isCurrent: () => true });
await f.session.control(true);
f.request.mockRejectedValueOnce(new Error("INVOKE_TIMEOUT"));
await expect(f.session.control(false)).rejects.toThrow("INVOKE_TIMEOUT");
await expect(f.session.control(true)).rejects.toThrow("DESKTOP_INPUT_BUSY");
f.request
.mockResolvedValueOnce({ controlling: true })
.mockResolvedValueOnce({ controlling: false });
expect(await f.session.heartbeat()).toEqual({ controlling: false });
expect(f.request.mock.calls.at(-1)?.[0]).toEqual({
op: "control",
lease: "lease",
enabled: false,
});
});
it.each([false, true])("stop preserves lock=%s when cleaning up a cancelled pending start", async (lockScreen) => {
const f = fixture();
let finish!: (value: unknown) => void;
const started = deferred<void>();
f.request.mockResolvedValueOnce(caps).mockImplementationOnce(
() =>
new Promise((resolve) => {
finish = resolve;
started.resolve();
}),
);
const connection = f.session.connect({ isCurrent: () => true });
await started.promise;
const stopping = f.session.stop(lockScreen);
// A second ordinary cleanup cannot undo the earlier lock requirement.
const secondStop = f.session.stop();
finish({ lease: "late" });
await expect(connection).rejects.toThrow("DESKTOP_VIDEO_STOPPED");
await stopping;
await secondStop;
expect(f.request.mock.calls.at(-1)?.[0]).toEqual({
op: "stop",
lease: "late",
...(lockScreen ? { lockScreen: true } : {}),
});
});
function deferred<T>() {
let resolve!: (value: T | PromiseLike<T>) => void;
let reject!: (reason: Error) => void;
const promise = new Promise<T>((done, fail) => {
resolve = done;
reject = fail;
});
return { promise, resolve, reject };
}
it.each([false, true])(
"waits for unlock preparation and respects cancellation=%s",
async (cancel) => {
const f = fixture();
const ready = deferred<void>();
const entered = deferred<void>();
const connecting = f.session.connect({
isCurrent: () => true,
onCapabilities: () => {
entered.resolve();
return ready.promise;
},
});
await entered.promise;
expect(f.request.mock.calls.map(([r]) => r.op)).toEqual(["capabilities"]);
const stopping = cancel ? f.session.stop() : undefined;
ready.resolve();
if (cancel) {
await expect(connecting).rejects.toThrow("DESKTOP_VIDEO_STOPPED");
await stopping;
expect(f.request.mock.calls.map(([r]) => r.op)).toEqual(["capabilities"]);
} else {
await connecting;
expect(f.request.mock.calls.map(([r]) => r.op)).toEqual([
"capabilities",
"start",
]);
}
},
);
it("does not mark a capabilities failure as a start attempt on an older host", async () => {
const current = fixture();
const onStart = vi.fn();
current.request.mockRejectedValueOnce(new Error("INVOKE_TIMEOUT"));
await expect(
current.session.connect({ isCurrent: () => true, onStart }),
).rejects.toThrow("INVOKE_TIMEOUT");
expect(onStart).not.toHaveBeenCalled();
current.request.mockResolvedValueOnce({
...caps,
automaticReconnect: undefined,
});
await current.session.connect({ isCurrent: () => true, onStart });
expect(onStart).toHaveBeenCalledOnce();
expect(
current.request.mock.calls.filter(([request]) => request.op === "start"),
).toHaveLength(1);
});
it("waits for late-start cleanup and skips superseded display choices", async () => {
const firstStart = deferred<unknown>();
const firstStarted = deferred<void>();
const cleanup = deferred<unknown>();
const cleaning = deferred<void>();
const request = vi.fn(async (operation: RemoteDesktopRequest) => {
if (operation.op === "capabilities")
return {
...caps,
displays: [{ id: "one" }, { id: "two" }, { id: "three" }],
};
if (operation.op === "start") {
if (operation.displayId === "one") {
firstStarted.resolve();
return firstStart.promise;
}
return {
lease: operation.displayId,
display: { id: operation.displayId },
controlling: false,
};
}
if (operation.op === "stop" && operation.lease === "late") {
cleaning.resolve();
return cleanup.promise;
}
return {};
});
const session = new RemoteDesktopViewerSession(
request as DesktopViewerRequest,
);
const first = session
.connect({ isCurrent: () => true, displayId: "one" })
.catch((error) => error.message);
await firstStarted.promise;
const firstStop = session.stop();
const second = session
.connect({ isCurrent: () => true, displayId: "two" })
.catch((error) => error.message);
const secondStop = session.stop();
const latest = session.connect({ isCurrent: () => true, displayId: "three" });
firstStart.resolve({
lease: "late",
display: { id: "one" },
controlling: false,
});
await cleaning.promise;
expect(
request.mock.calls.filter(([operation]) => operation.op === "start"),
).toHaveLength(1);
cleanup.resolve({});
await expect(first).resolves.toBe("DESKTOP_VIDEO_STOPPED");
await expect(second).resolves.toBe("DESKTOP_VIDEO_STOPPED");
await Promise.all([firstStop, secondStop]);
await expect(latest).resolves.toMatchObject({ lease: { lease: "three" } });
expect(
request.mock.calls
.filter(([operation]) => operation.op === "start")
.map(([operation]) => operation),
).toEqual([
{ op: "start", displayId: "one" },
{ op: "start", displayId: "three" },
]);
});
it("keeps another peer responsive while one viewer stops an unacknowledged start", async () => {
const blocked = deferred<unknown>();
const started = deferred<void>();
const transport = vi.fn(
async (peer: string, operation: RemoteDesktopRequest) => {
if (operation.op === "capabilities") return caps;
if (operation.op === "start" && peer === "paused") {
started.resolve();
return blocked.promise;
}
if (operation.op === "start")
return {
lease: "other-lease",
controlling: false,
display: { id: "screen" },
};
return { controlling: true };
},
);
const paused = new RemoteDesktopViewerSession(((request) =>
transport("paused", request)) as DesktopViewerRequest);
const other = new RemoteDesktopViewerSession(((request) =>
transport("other", request)) as DesktopViewerRequest);
const pending = paused
.connect({ isCurrent: () => true })
.catch((error) => error.message);
await started.promise;
const stopped = paused.stop();
await other.connect({ isCurrent: () => true });
await other.control(true);
await expect(other.heartbeat()).resolves.toEqual({ controlling: true });
blocked.reject(new Error("DESKTOP_BUSY"));
await pending;
await stopped;
await expect(other.heartbeat()).resolves.toEqual({ controlling: true });
expect(other.lease?.lease).toBe("other-lease");
expect(
transport.mock.calls.some(
([peer, request]) => peer === "other" && request.op === "stop",
),
).toBe(false);
});
it("keeps confirmed control when an older heartbeat omits its projection", async () => {
const f = fixture();
await f.session.connect({ isCurrent: () => true });
await f.session.control(true);
f.request.mockResolvedValueOnce({});
expect(await f.session.heartbeat()).toEqual({ controlling: true });
});
it("a 代输入 window view names only the request, hides controls past the window and refuses a whole display", async () => {
const f = fixture();
const full = { ...caps, handoffWindow: true, clipboardText: true, displayModes: true, privacyScreen: true, systemAudio: true, autoControl: true };
f.request.mockResolvedValueOnce(full).mockResolvedValueOnce({
lease: "lease",
display: { id: "screen" },
controlling: true,
window: { app: "Game", title: "Sign in" },
});
const seen = vi.fn();
const { caps: shown, lease } = await f.session.connect({
isCurrent: () => true,
handoff: "req1",
control: true,
onCapabilities: seen,
});
expect(f.request.mock.calls[1][0]).toEqual({ op: "start", displayId: "screen", control: true, handoff: "req1" });
expect(shown).toMatchObject({ handoffWindow: true, autoControl: true, canControl: true });
for (const key of ["clipboardText", "displayModes", "privacyScreen", "systemAudio", "connectionTakeover"])
expect(shown).not.toHaveProperty(key);
expect(seen).toHaveBeenCalledWith(shown);
expect(lease.window).toEqual({ app: "Game", title: "Sign in" });
await f.session.stop();
// An older host cannot show a single window.
f.request.mockResolvedValueOnce(caps);
await expect(f.session.connect({ isCurrent: () => true, handoff: "req1" })).rejects.toThrow("CHANNEL_NOT_ALLOWED");
// A host that answers with the whole display is released at once.
f.request.mockResolvedValueOnce(full).mockResolvedValueOnce({ lease: "whole", display: { id: "screen" } });
await expect(f.session.connect({ isCurrent: () => true, handoff: "req1" })).rejects.toThrow("INVALID_RESPONSE");
expect(f.request.mock.calls.at(-1)?.[0]).toEqual({ op: "stop", lease: "whole" });
expect(f.session.lease).toBeNull();
});