scripts/testing/one-workspace-fixture.ts
Rama main · réplica de lectura del repositorio original.
// The desktop window onto My Cloud, in a real headless Chrome, with main's own handlers: the home window
// (electron/home-window.mjs), its IPC, the startup screen, the permission rule, and main.mjs's own chat-link delivery,
// against the two real servers of cloud-send-fixture.ts. Chrome stands in for Electron: each window is a Chrome tab
// driven over the DevTools protocol, the real preload runs in every page it loads (its ipcRenderer reaches main's
// handlers over loopback), webRequest's onCompleted is Chrome's own response events, and the permission handler's answer
// is set on Chrome per origin as each page loads. My Cloud's page and this computer's are the real renderer from source
// (Vite), each served at its own origin: My Cloud's through an edge that adds the Cloud's own headers, this computer's
// asking this computer's real, frozen server which page it serves. A team's Cloud is the same Cloud-mode server behind a
// third edge at its own origin (for opening, a Team Cloud is a My Cloud), paired through a fake Admin's team pairing
// route on this harness's own server, so main's team path (home-places.mjs, the session's teams as saved places) runs
// as it does in the app. With `profiles`, This Mac is there too: main's real profile swap (clean-workspace.mjs) restarts
// this computer's server on the profile's folder at the same address, the window's rail is its own page in a second tab
// with main's rail handlers (cloud-rail.mjs), and this computer is really lent to My Cloud (computer-sharing.mjs over
// lending-target.mjs) on the window's own session.
import { spawn, type ChildProcess } from "node:child_process";
import { EventEmitter } from "node:events";
import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
import { createServer as createHttpServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import vm from "node:vm";
import { createServer as createViteServer, type ViteDevServer } from "vite";
import { appPermissionHandlers } from "../../electron/app-permissions.mjs";
import capabilities from "../../electron/capabilities.cjs";
import { chatLinkFrom } from "../../electron/chat-link.mjs";
import { createCleanWorkspace } from "../../electron/clean-workspace.mjs";
import { createLocalProfiles, createProfileRegistry } from "../../electron/local-profiles.mjs";
import { parsePairingGrant, withCloudHome } from "../../electron/cloud-home.mjs";
import { installCloudRail, railPlaces } from "../../electron/cloud-rail.mjs";
import { createComputerSharing } from "../../electron/computer-sharing.mjs";
import { createLendingTarget } from "../../electron/lending-target.mjs";
import { createCloudPowerGate } from "../../electron/cloud-power.mjs";
import environments from "../../electron/environments.cjs";
import { createHomePlaces } from "../../electron/home-places.mjs";
import { openStartPlace } from "../../electron/start-place.mjs";
import { createHomeWindow, installHomeWindowIpc, HOME_SCREEN_PATH } from "../../electron/home-window.mjs";
import { createStartupScreen } from "../../electron/startup-screen.mjs";
import { packageUrlFromDeepLink } from "../../electron/package-link.mjs";
import { WELCOME_VERSION } from "../../electron/onboarding-record.mjs";
import { SPOTLIGHTS } from "../../src/lib/first-conversation.ts";
import { TOUR_STEPS } from "../../src/lib/guided-tour.ts";
import { NOTICES } from "../../src/lib/notices.ts";
import { waitForExit } from "../../server/testing/cleanup.ts";
import type { CloudSendFixture } from "./cloud-send-fixture.ts";
import { REPO_ROOT } from "./preview-fixture.ts";
const PRELOAD = readFileSync(join(REPO_ROOT, "electron", "preload.cjs"), "utf8");
const MAIN = readFileSync(join(REPO_ROOT, "electron", "main.mjs"), "utf8").replace(/\r\n/g, "\n");
const SPLASH_ICON = join(REPO_ROOT, "electron", "resources", "app-icon.png");
export const ACCOUNT_ID = "acct-fixture";
/** The renderer's own routes to its server; the same keys as vite.config.ts, so none of its own targets is kept. */
const PROXIED = ["/api", "/.well-known/openmausbot/environment"];
type Cdp = Awaited<ReturnType<typeof connectCdp>>;
type Handler = (params: any, sessionId?: string) => void;
async function connectCdp(url: string) {
const socket = new WebSocket(url);
const pending = new Map<number, { resolve: (value: any) => void; reject: (error: Error) => void }>();
const listeners = new Map<string, Set<Handler>>();
let next = 0;
socket.addEventListener("message", (event) => {
const message = JSON.parse(String(event.data));
if (message.method) for (const listener of listeners.get(message.method) ?? []) listener(message.params, message.sessionId);
const waiting = pending.get(message.id);
if (!waiting) return;
pending.delete(message.id);
if (message.error) waiting.reject(new Error(message.error.message)); else waiting.resolve(message.result);
});
await new Promise<void>((resolve, reject) => {
socket.addEventListener("open", () => resolve(), { once: true });
socket.addEventListener("error", () => reject(new Error("Fixture Chrome connection failed")), { once: true });
});
return {
request(method: string, params: unknown = {}, sessionId?: string): Promise<any> {
const id = ++next;
return new Promise((resolve, reject) => {
const timer = setTimeout(() => { pending.delete(id); reject(new Error(`Fixture Chrome ${method} timed out`)); }, 60_000);
pending.set(id, { resolve: (value) => { clearTimeout(timer); resolve(value); }, reject: (error) => { clearTimeout(timer); reject(error); } });
socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
});
},
on(method: string, listener: Handler) {
if (!listeners.has(method)) listeners.set(method, new Set());
listeners.get(method)!.add(listener);
return () => listeners.get(method)!.delete(listener);
},
close() { for (const waiting of pending.values()) waiting.reject(new Error("closed")); socket.close(); },
};
}
let ids = 100;
/** One Electron window, as a Chrome tab: the part of BrowserWindow and its webContents main and the startup screen use. */
export class TabWindow extends EventEmitter {
readonly cdp: Cdp;
readonly targetId: string;
readonly sessionId: string;
readonly webContents: EventEmitter & Record<string, any>;
url = "about:blank";
destroyed = false;
visible = false;
loads = 0;
private readyShown = false;
constructor(cdp: Cdp, targetId: string, sessionId: string) {
super();
this.cdp = cdp; this.targetId = targetId; this.sessionId = sessionId;
const contents = new EventEmitter() as EventEmitter & Record<string, any>;
contents.id = ids++;
contents.mainFrame = { url: "" };
Object.defineProperty(contents.mainFrame, "url", { get: () => this.url });
contents.getURL = () => this.url;
contents.isDestroyed = () => this.destroyed;
contents.isLoadingMainFrame = () => false;
contents.focus = () => {};
contents.send = (channel: string, ...args: unknown[]) => { void this.evaluate(`window.__ogbEmit?.(${JSON.stringify(channel)}, ...${JSON.stringify(args)})`).catch(() => {}); };
contents.executeJavaScript = (code: string) => this.evaluate(code);
contents.reload = () => { void cdp.request("Page.reload", {}, sessionId).catch(() => {}); };
this.webContents = contents;
cdp.on("Page.frameNavigated", ({ frame }, from) => {
if (from !== sessionId || frame.parentId) return;
this.url = `${frame.url}${frame.urlFragment ?? ""}`;
contents.emit("did-navigate", {}, this.url);
});
cdp.on("Page.navigatedWithinDocument", ({ url }, from) => { if (from === sessionId) this.url = url; });
cdp.on("Page.loadEventFired", (_params, from) => {
if (from !== sessionId) return;
this.loads++;
contents.emit("did-finish-load");
contents.emit("did-stop-loading");
if (!this.readyShown) { this.readyShown = true; this.emit("ready-to-show"); }
});
cdp.on("Network.loadingFailed", ({ type, errorText, canceled }, from) => {
if (from !== sessionId || type !== "Document" || canceled) return;
contents.emit("did-fail-load", {}, -2, errorText, this.url, true);
});
}
static async open(cdp: Cdp, init?: string): Promise<TabWindow> {
const { targetId } = await cdp.request("Target.createTarget", { url: "about:blank" });
const { sessionId } = await cdp.request("Target.attachToTarget", { targetId, flatten: true });
for (const domain of ["Page.enable", "Runtime.enable", "Network.enable"]) await cdp.request(domain, {}, sessionId);
if (init) await cdp.request("Page.addScriptToEvaluateOnNewDocument", { source: init }, sessionId);
return new TabWindow(cdp, targetId, sessionId);
}
async evaluate<T = any>(expression: string): Promise<T> {
const value = await this.cdp.request("Runtime.evaluate", { expression, awaitPromise: true, returnByValue: true }, this.sessionId);
if (value.exceptionDetails) throw new Error(value.exceptionDetails.exception?.description ?? value.exceptionDetails.text);
return value.result.value as T;
}
async loadURL(url: string): Promise<void> {
const answer = await this.cdp.request("Page.navigate", { url }, this.sessionId);
if (answer.errorText) throw new Error(answer.errorText);
}
async screenshot(file: string): Promise<void> {
const shot = await this.cdp.request("Page.captureScreenshot", { format: "png" }, this.sessionId);
const { writeFileSync } = await import("node:fs");
writeFileSync(file, Buffer.from(shot.data, "base64"));
}
setMenu() {}
show() { this.visible = true; this.emit("show"); }
showInactive() { this.show(); }
hide() { this.visible = false; }
focus() {}
isVisible() { return this.visible; }
isMinimized() { return false; }
minimize() {}
maximize() {}
setSkipTaskbar() {}
isDestroyed() { return this.destroyed; }
close() { this.destroy(); }
destroy() {
if (this.destroyed) return;
this.destroyed = true;
void this.cdp.request("Target.closeTarget", { targetId: this.targetId }).catch(() => {});
this.emit("closed");
}
}
function readBody(req: IncomingMessage): Promise<string> {
return new Promise((resolve) => { let text = ""; req.on("data", (chunk) => { text += chunk; }); req.on("end", () => resolve(text)); });
}
/** Electron's preload in a Chrome page: the real preload.cjs, its `require("electron")` and argv given by this harness. */
function preloadStandIn(ipcBase: string, localOrigin: string, tab = "window"): string {
return `(() => {
if (!/^https?:/.test(location.protocol)) return;
try { localStorage.setItem("omb-analytics-opt-out", "1"); localStorage.setItem("omb-email-gate", "skipped"); localStorage.setItem("omb-advanced-mode", "0");
for (const notice of ${JSON.stringify(NOTICES)}) localStorage.setItem(notice, "1"); } catch {}
const listeners = new Map();
window.__ogbEmit = (channel, ...args) => { for (const listener of [...(listeners.get(channel) ?? [])]) listener({}, ...args); };
let sent = 0;
const call = async (channel, args) => {
const response = await fetch(${JSON.stringify(ipcBase)} + "/__ipc/" + channel + "?tab=${tab}&seq=" + (++sent), { method: "POST", headers: { "content-type": "text/plain" }, body: JSON.stringify({ args }) });
const answer = await response.json();
if (!response.ok) throw new Error(answer.error);
return answer.value;
};
const ipcRenderer = {
invoke: (channel, ...args) => call(channel, args),
send: (channel, ...args) => { void call(channel, args).catch(() => {}); },
sendSync: (channel, ...args) => {
const request = new XMLHttpRequest();
request.open("POST", ${JSON.stringify(ipcBase)} + "/__ipc-sync/" + channel + "?tab=${tab}", false);
request.setRequestHeader("content-type", "text/plain");
request.send(JSON.stringify({ args }));
try { return JSON.parse(request.responseText).value; } catch { return undefined; }
},
on: (channel, listener) => { if (!listeners.has(channel)) listeners.set(channel, new Set()); listeners.get(channel).add(listener); },
removeListener: (channel, listener) => { listeners.get(channel)?.delete(listener); },
};
const electron = { contextBridge: { exposeInMainWorld: (key, value) => { window[key] = value; } }, ipcRenderer, webUtils: { getPathForFile: () => "" } };
const process = { platform: "darwin", argv: ["--omb-local-origin=${localOrigin}", "--omb-company-desktop=1"] };
(function (require, process) {
${PRELOAD}
})(() => electron, process);
})();`;
}
export interface HomeWorld {
/** My Cloud as this window reaches it, and this computer's own page. */
cloudOrigin: string;
localOrigin: string;
/** A team's Cloud: the same Cloud-mode server at its own origin. */
teamOrigin: string;
/** Another saved server, for a page that is neither. */
otherOrigin: string;
window: TabWindow;
/** The startup screen of the last launch, while it is up. */
splash: TabWindow | null;
home: ReturnType<typeof createHomeWindow>;
/** A launch of the app: the startup screen, then show() as main's launch does. */
launch(): Promise<void>;
/** The MausBot Cloud sign-in main reads: its state, and the power word of a Cloud that sleeps. */
account: { state: Record<string, any>; power: { state: "awake" | "asleep" | "waking"; since: number; sleeps: true } | null; wakeMs: number; wakes: number; signIns: string[] };
/** Down: every request on the way to My Cloud fails, the window's and main's alike; `teamDown`: the team's Cloud only;
* `nameMissing`: My Cloud's name isn't found (a resolver kept the answer it got while My Cloud was set up). */
network: { down: boolean; teamDown: boolean; nameMissing: boolean };
/** False: the move hasn't happened, so My Cloud is a saved server this window opens when asked (no journal, no freeze). */
moved: boolean;
/** How often the window's Electron session had its host cache cleared. */
hostCache: { cleared: number };
/** The fake Admin: each team pairing it signed, by team id; `removed`: teams whose pairing it refuses (404), as for a
* member removed while the session still lists the team. */
admin: { teamPairings: string[]; removed: Set<string> };
/** Main's places (home-places.mjs) and its saved servers, as the app keeps them. */
places: ReturnType<typeof createHomePlaces>;
environments(): { environments: any[]; activeId: string };
/** The switcher's entries as main's native menu would list them (environments.cjs). */
menu(): Array<{ label?: string; sublabel?: string; checked?: boolean }>;
/** The MausBot Cloud sign-in changed: main's own two steps (the places follow the session, then the window). */
sync(): Promise<void>;
/** With `profiles`: the window's rail as its own page, main's list for it, the profile swap and this computer's lending. */
rail: TabWindow | null;
railList(): ReturnType<typeof railPlaces>;
clean: ReturnType<typeof createCleanWorkspace> | null;
lending: ReturnType<typeof createComputerSharing> | null;
/** The folder this computer's server runs on now. */
running(): string;
/** With `profiles`: the workspaces of this computer's own as main keeps them (local-profiles.mjs), and the Trash a
* removed one goes to. */
registry: ReturnType<typeof createProfileRegistry> | null;
readonly profiles: ReturnType<typeof createLocalProfiles> | null;
trashDir: string;
/** A sheet of the rail's is open: its view covers the window. */
railCovers(): boolean;
setSize(width: number, height: number): Promise<void>;
/** The OS's light or dark look, which both pages follow. */
theme(dark: boolean): Promise<void>;
/** The app quits and opens again: this computer's server stopped as a quit stops it and started on the data folder, then
* `whileClosed` (what changes while the app is closed), and a new home window that knows nothing of the last run opens the
* place remembered from it, as a launch does. */
restartApp(whileClosed?: () => unknown): Promise<void>;
/** Each request My Cloud's edge passed on, in order. */
cloudRequests: Array<{ path: string; at: number }>;
/** main.mjs's own chat-link delivery, as a link from the OS reaches it. */
openLink(link: string): boolean;
/** What main's permission handler decided for the last pages, by origin. */
notifications: Map<string, boolean>;
/** The window's session cookie on My Cloud. */
cloudCookies(): Promise<Array<{ name: string; value: string }>>;
close(): Promise<void>;
}
/** Both sides past their welcome, so a page opens straight on its chats. */
export async function welcomed(fx: CloudSendFixture): Promise<void> {
const onboarding = { completedAt: new Date().toISOString(), version: WELCOME_VERSION, hintsSeen: [...TOUR_STEPS.map((step) => step.id), ...SPOTLIGHTS] };
await fx.local("PATCH", "/api/config", { onboarding, language: "en" });
await fx.onCloud("PATCH", "/api/config", { onboarding: { ...onboarding, hintsSeen: [...onboarding.hintsSeen, "cloud-welcome-done", "cloud-setup-hidden"] }, language: "en" });
}
async function vite(port: number, host: string, plugin: (server: ViteDevServer) => void, proxy: Record<string, unknown>): Promise<ViteDevServer> {
const server = await createViteServer({
root: REPO_ROOT, logLevel: "warn", clearScreen: false,
server: { host, port, strictPort: true, proxy: proxy as never, hmr: { port: port + 1 } },
plugins: [{ name: "one-workspace-edge", configureServer: plugin }],
});
await server.listen();
return server;
}
/** `chrome`: the pinned Chrome for Testing; `ports`: two free pairs (each Vite server takes its port and the next). */
export async function launchHomeWorld(fx: CloudSendFixture, { chrome, ports, versionEveryMs = 1_000, quietMs = 1_500, profiles = false }: {
chrome: string; ports: [number, number, number, number]; versionEveryMs?: number; quietMs?: number; profiles?: boolean;
}): Promise<HomeWorld> {
const [cloudPort, localPort, ipcPort, teamPort] = ports;
const cloudOrigin = `http://localhost:${cloudPort}`;
const localOrigin = `http://127.0.0.1:${localPort}`;
const ipcBase = `http://127.0.0.1:${ipcPort}`;
// Its own host, not another localhost port: a browser's cookies are per host, and the team's session must be its own.
const teamOrigin = `http://[::1]:${teamPort}`;
const otherOrigin = ipcBase;
const network = { down: false, teamDown: false, nameMissing: false };
const moves = { moved: true };
const hostCache = { cleared: 0 };
const admin: HomeWorld["admin"] = { teamPairings: [], removed: new Set() };
const cloudRequests: HomeWorld["cloudRequests"] = [];
const notifications = new Map<string, boolean>();
const account: HomeWorld["account"] = {
state: { status: "connected", account: { id: ACCOUNT_ID, email: "person@example.test" }, entitlement: { plan: "pro", status: "active", expiresAt: null, version: 1 },
machine: { status: "ready", origin: cloudOrigin } },
power: null, wakeMs: 1_500, wakes: 0, signIns: [],
};
const cleanup: Array<() => Promise<unknown> | unknown> = [];
let windowRef: TabWindow | null = null, homeRef: ReturnType<typeof createHomeWindow> | null = null, responded: ((details: any) => void) | null = null;
let railRef: TabWindow | null = null, railHandlers: ReturnType<typeof installCloudRail> | null = null;
let railCovers = false;
const size = { width: 1280, height: 800 };
// My Cloud's edge: the renderer from source, and its API on the real Cloud-mode server with the edge's own headers.
const cloudEdge = await vite(cloudPort, "localhost", (server) => {
server.middlewares.use((req, res, next) => {
if (network.down || network.nameMissing) { req.socket.destroy(); return; }
if ((req.url ?? "").startsWith("/api/") || (req.url ?? "").startsWith("/.well-known/")) cloudRequests.push({ path: (req.url ?? "").split("?")[0]!, at: Date.now() });
next();
});
}, Object.fromEntries(PROXIED.map((path) => [path, {
target: fx.cloudBase, ws: true, headers: fx.edge,
configure: (proxy: EventEmitter) => {
proxy.on("proxyRes", (proxyRes: IncomingMessage) => {
const cookies = proxyRes.headers["set-cookie"];
if (cookies) proxyRes.headers["set-cookie"] = cookies.map((cookie) => cookie.replace(/;\s*Secure/giu, ""));
});
},
}])));
cleanup.push(() => cloudEdge.close());
// The team's Cloud: the same server, its own origin (so its own cookie, its own page).
const teamEdge = await vite(teamPort, "::1", (server) => {
server.middlewares.use((req, _res, next) => { if (network.teamDown) { req.socket.destroy(); return; } next(); });
}, Object.fromEntries(PROXIED.map((path) => [path, {
target: fx.cloudBase, ws: true, headers: fx.edge,
configure: (proxy: EventEmitter) => {
proxy.on("proxyRes", (proxyRes: IncomingMessage) => {
const cookies = proxyRes.headers["set-cookie"];
if (cookies) proxyRes.headers["set-cookie"] = cookies.map((cookie) => cookie.replace(/;\s*Secure/giu, ""));
});
},
}])));
cleanup.push(() => teamEdge.close());
// This computer's page: the same renderer, and its real server, as the desktop's owner, decides which page it serves.
const localEdge = await vite(localPort, "127.0.0.1", (server) => {
server.middlewares.use(async (req, res, next) => {
const path = (req.url ?? "/").split("?")[0]!;
const page = req.method === "GET" && !path.startsWith("/api/") && !path.startsWith("/@") && !path.startsWith("/src/") && !path.startsWith("/node_modules/")
&& !/\.[A-Za-z0-9]+$/u.test(path) && (req.headers.accept ?? "").includes("text/html");
if (!page) return next();
const real = await fetch(`${fx.desktopBase}${req.url}`, { redirect: "manual" }).catch(() => null);
if (real && real.status >= 300 && real.status < 400) {
res.statusCode = real.status;
res.setHeader("location", real.headers.get("location") ?? HOME_SCREEN_PATH);
res.end();
return;
}
next();
});
}, Object.fromEntries(PROXIED.map((path) => [path, { target: fx.desktopBase, ws: true, headers: { "x-openmausbot-desktop-owner": fx.ownerCapability } }])));
cleanup.push(() => localEdge.close());
// Main's ipcMain, reached by the preload's ipcRenderer.
const handlers = new Map<string, (...args: any[]) => unknown>();
/** The last invoke each tab's page sent that main has started on. */
const started = new Map<string, number>();
const syncHandlers = new Map<string, (event: any) => void>();
const ipcMain = { handle: (channel: string, handler: (...args: any[]) => unknown) => { handlers.set(channel, handler); }, on: (channel: string, listener: (event: any) => void) => { syncHandlers.set(channel, listener); } };
const ipc: Server = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
res.setHeader("access-control-allow-origin", "*");
const [path = "", query = ""] = (req.url ?? "").split("?");
const sync = /^\/__ipc-sync\/([\w:.-]+)$/.exec(path), asked = /^\/__ipc\/([\w:.-]+)$/.exec(path);
const reply = (status: number, value: unknown) => { res.writeHead(status, { "content-type": "application/json" }); res.end(JSON.stringify(value)); };
// The fake Admin's team pairing: only for a team the session lists, answered as the Admin answers (docs/team-cloud.md).
const teamPairing = /^\/api\/cloud\/desktop\/teams\/([^/]+)\/pairing$/.exec(req.url ?? "");
if (teamPairing) {
const id = decodeURIComponent(teamPairing[1]!);
const listed = req.method === "POST" && req.headers.authorization === "Bearer omc_fixture" && account.state.status === "connected" && (account.state.teams ?? []).some((team: any) => team.id === id) && !admin.removed.has(id);
if (!listed) return reply(404, { error: "not_found" });
admin.teamPairings.push(id);
const grant = await fx.grant("OpenMausBot app (Team Cloud)");
return reply(200, { cloudContractVersion: 1, origin: teamOrigin, code: grant.code, pairingUrl: `${teamOrigin}/pair#code=${grant.code}`, expiresAt: grant.expiresAt, credential: "omb_pair_fixture" });
}
if (!sync && !asked) { res.writeHead(200, { "content-type": "text/html" }); res.end("<!doctype html><title>Another server</title><p>Another server</p>"); return; }
const { args = [] } = JSON.parse((await readBody(req)) || "{}") as { args?: unknown[] };
const params = new URLSearchParams(query), tab = params.get("tab") ?? "window", seq = Number(params.get("seq") ?? 0);
// Electron hands a page's invokes to main in the order the page sent them; separate HTTP requests may arrive in any.
for (let waits = 0; asked && seq > 1 && (started.get(tab) ?? 0) < seq - 1 && waits < 40; waits++) await new Promise((resolve) => setTimeout(resolve, 50));
if (asked) started.set(tab, seq);
const win = tab === "rail" && railRef ? railRef : windowRef!;
const event: Record<string, any> = { sender: win.webContents, senderFrame: win.webContents.mainFrame };
if (sync) {
const listener = syncHandlers.get(sync[1]!);
if (listener) listener(event);
return reply(200, { value: event.returnValue ?? null });
}
const channel = asked![1]!;
const handler = handlers.get(channel) ?? STAND_INS[channel];
if (!handler) return reply(400, { error: `${channel} is not wired in this harness` });
try { reply(200, { value: (await handler(event, ...args)) ?? null }); }
catch (error) { reply(400, { error: error instanceof Error ? error.message : String(error) }); }
});
await new Promise<void>((resolve) => ipc.listen(ipcPort, "127.0.0.1", resolve));
cleanup.push(() => new Promise((resolve) => ipc.close(resolve)));
// Channels of the page this harness does not drive, answered as main answers a page that has nothing to say.
const STAND_INS: Record<string, (...args: any[]) => unknown> = {
"desktop:capabilities": (event) => capabilities.desktopCapabilities({ remote: new URL(event.senderFrame.url).origin !== localOrigin, platform: "darwin", env: {}, packaged: true, localConnection: { mode: "unavailable", reason: "fixture" } }),
"workspaces:state": (event) => ({ ...environments.workspaceSummary(envState), ...(homeAlone() && homeRef!.homePage(event) ? { home: true } : {}),
...(clean?.profile() && new URL(event.senderFrame.url).origin === localOrigin ? { profile: clean.profile(), ...(localProfiles?.name(clean.profile()!) ? { profileName: localProfiles.name(clean.profile()!) } : {}) } : {}) }),
"workspaces:menu": () => null,
"workspaces:line": (event) => (clean?.active() && new URL(event.senderFrame.url).origin === localOrigin ? (clean.profile() ? { kind: "profile", ...(localProfiles?.name(clean.profile()!) ? { name: localProfiles.name(clean.profile()!) } : {}) } : { kind: "clean" }) : homePlaces.line()),
"rail:offer": () => ({ available: true, hidden: false }),
// chrome-rail.mjs: while a sheet of the rail's is open, its view covers the window, see-through but for the sheet.
"rail:expand": async (_event, covering) => {
railCovers = covering === true;
if (railRef) await cdp.request("Emulation.setDeviceMetricsOverride", { width: railCovers ? size.width : 36, height: size.height, deviceScaleFactor: 2, mobile: false }, railRef.sessionId);
},
"rail:draws-frame": () => null,
"desktop-notices:state": () => ({ seen: [...NOTICES], cloud: false }),
"desktop-notices:seen": () => null,
"cloud-plan:state": () => ({ status: "paid", tier: "pro", home: true }),
"cloud-send:notice": () => ({ ready: false, bots: [], updatedBots: [], skills: 0, logins: 0, onePassword: false, settings: 0, signature: "", dismissed: false, running: false, last: null, whole: null }),
"update:get-state": () => ({ status: "idle" }),
"perm:status": () => ({ mic: "unsupported", pageMic: "refused" }),
};
// Chrome, its two tabs' worth of windows.
const profile = mkdtempSync(join(tmpdir(), "omb-one-workspace-chrome-"));
cleanup.push(() => rmSync(profile, { recursive: true, force: true }));
const browser: ChildProcess = spawn(chrome, ["--headless=new", "--no-sandbox", "--no-first-run", "--no-default-browser-check", "--disable-background-networking",
"--password-store=basic", "--use-mock-keychain", "--remote-debugging-port=0", `--user-data-dir=${profile}`, "about:blank"], {
env: { PATH: process.env.PATH, HOME: profile, USERPROFILE: profile }, stdio: "ignore",
});
cleanup.unshift(() => waitForExit(browser, { signal: "SIGTERM" }));
const portFile = join(profile, "DevToolsActivePort");
for (let tries = 0; !existsSync(portFile) && tries < 200; tries++) await new Promise((resolve) => setTimeout(resolve, 100));
const [devPort, endpoint] = readFileSync(portFile, "utf8").trim().split("\n");
const cdp = await connectCdp(`ws://127.0.0.1:${devPort}${endpoint}`);
cleanup.unshift(() => cdp.close());
const init = preloadStandIn(ipcBase, localOrigin);
const win = await TabWindow.open(cdp, init);
windowRef = win;
cdp.on("Network.responseReceived", ({ response, type }, from) => {
if (from !== win.sessionId || type === "Document") return;
responded?.({ url: response.url, statusCode: response.status, webContentsId: win.webContents.id });
});
// Main's own handlers. Saved servers and places as main keeps them, in memory here.
let envState: { environments: any[]; activeId: string } = { environments: [], activeId: environments.LOCAL_ID };
let envIds = 0;
const makeId = () => `env-${++envIds}`;
const persist = (next: typeof envState) => { envState = next; railHandlers?.changed(); };
let placeRecord: unknown = null;
const homePlaces = createHomePlaces({ store: { read: () => placeRecord, write: (value) => { placeRecord = value; } }, environments: () => envState, persist, makeId, homeOrigin: () => homeRef?.cloudOrigin() ?? null });
const homeAlone = () => Boolean(homeRef?.cloudOrigin()) && !environments.otherPlaces(envState, homeRef!.cloudOrigin());
/** main.mjs's activateCloud / activateTeam / back to this computer, as its `go` does them. */
const activate = (origin: string | null, place: any) => {
if (place?.kind === "team") {
const next = environments.withTeam(envState, place, makeId);
persist(environments.withActive(next, next.environments.find((entry: any) => entry.origin === place.origin).id));
} else if (origin) {
const next = withCloudHome(envState, { status: "ready", origin }, makeId);
persist(environments.withActive(next, next.environments.find((entry: any) => entry.origin === origin).id));
} else if (environments.activeEnvironment(envState)) persist(environments.withActive(envState, environments.LOCAL_ID));
};
const power = createCloudPowerGate({ power: () => account.power });
const appPermissions = appPermissionHandlers({ rendererOrigin: () => localOrigin, mainContents: () => win.webContents, cloudHomeOrigin: () => cloudOrigin,
homeOrigin: () => homeRef?.placeOrigin() ?? null });
win.webContents.on("did-navigate", (_event: unknown, url: string) => {
const origin = new URL(url).origin;
if (!/^https?:/.test(url)) return;
const allowed = appPermissions.check(win.webContents, "notifications", origin, { isMainFrame: true }) === true;
notifications.set(origin, allowed);
void cdp.request("Browser.setPermission", { permission: { name: "notifications" }, setting: allowed ? "granted" : "denied", origin }).catch(() => {});
});
const pairHome = async () => {
if (account.state.status !== "connected" || network.down) throw new Error("My Cloud is not ready to connect yet.");
const grant = await fx.grant("OpenMausBot app (Cloud)");
return { ...grant, origin: cloudOrigin };
};
/** The real client's `pairTeam` shape against the fake Admin's route: the Admin's answer, read as the app reads it. */
const pairTeam = async (teamId: string) => {
if (network.down) throw new TypeError("fetch failed");
const response = await fetch(`${ipcBase}/api/cloud/desktop/teams/${encodeURIComponent(teamId)}/pairing`, { method: "POST", headers: { authorization: "Bearer omc_fixture" } });
if (!response.ok) throw Object.assign(new Error("Cloud request failed."), { status: response.status, ...(response.status === 404 ? { gone: true } : {}) });
const grant = parsePairingGrant(await response.json(), teamOrigin, Date.now());
if (!grant) throw new Error("Invalid Cloud pairing response.");
return grant;
};
const client = {
state: () => account.state,
power: () => account.power,
async wakeHome() {
account.wakes++;
await new Promise((resolve) => setTimeout(resolve, account.wakeMs));
if (account.power) account.power = { ...account.power, state: "awake", since: Date.now() };
power.changed();
return "awake";
},
setWaking: () => {},
pairHome,
pairTeam,
async signInAgain() { account.signIns.push("again"); },
async begin() { account.signIns.push("begin"); },
};
// The window's session's fetch: its cookies go along, and a cookie the answer sets is the window's from then on.
const cookieFetch = async (url: string, init: RequestInit = {}) => {
if (network.down || (network.teamDown && url.startsWith(teamOrigin)) || (network.nameMissing && url.startsWith(cloudOrigin))) throw new TypeError("fetch failed");
const { cookies } = await cdp.request("Network.getCookies", { urls: [url] }, win.sessionId);
const cookie = (cookies as Array<{ name: string; value: string }>).map((entry) => `${entry.name}=${entry.value}`).join("; ");
const response = await fetch(url, { ...init, headers: { ...(init.headers as Record<string, string>), ...(cookie ? { cookie } : {}) } });
for (const line of response.headers.getSetCookie()) {
const [pair = "", ...attributes] = line.split(";").map((part) => part.trim());
const at = pair.indexOf("="), path = attributes.find((part) => /^path=/i.test(part))?.slice(5) || "/";
if (at <= 0) continue;
const name = pair.slice(0, at), cookieUrl = new URL(url).origin + path;
// A cookie the answer clears (Max-Age=0) is deleted, never kept with an empty value, as Electron's session does.
if (attributes.some((part) => /^max-age=(0|-\d+)$/i.test(part))) await cdp.request("Network.deleteCookies", { name, url: cookieUrl }, win.sessionId);
else await cdp.request("Network.setCookie", { name, value: pair.slice(at + 1), url: cookieUrl, path, httpOnly: attributes.some((part) => /^httponly$/i.test(part)) }, win.sessionId);
}
return response;
};
const world = {
splash: null as TabWindow | null,
};
// main.mjs's cleanWorkspace: its swap is switchLocalEnvironmentTo's, one server at a time at the same address, then the
// window onto this computer's page with LOCAL_ID active.
let running = fx.desktopDataDir;
const clean = profiles ? createCleanWorkspace({
dataDir: () => fx.desktopDataDir, running: () => running,
swap: async (dir: string) => {
// A workspace's first config as the app writes it, with the fixture's AIs only, so nothing on this machine's PATH is used.
const config = join(dir, "config.json");
if (dir !== fx.desktopDataDir && existsSync(config)) {
const seeded = JSON.parse(readFileSync(config, "utf8"));
if (!seeded.instances) writeFileSync(config, JSON.stringify({ ...seeded, instances: JSON.parse(readFileSync(join(fx.desktopDataDir, "config.json"), "utf8")).instances }));
}
await fx.relaunch({ kill: false, ...(dir === fx.desktopDataDir ? {} : { dataDir: dir }) });
running = dir;
persist(environments.withActive(envState, environments.LOCAL_ID));
homeRef?.cancel();
await win.loadURL(`${localOrigin}/`).catch(() => {});
return { ok: true };
},
changed: () => lending?.cloudChanged(),
}) : null;
const ownCopy = async (route: string, init?: RequestInit) => fetch(`${fx.desktopBase}${route}`, { ...init, headers: { "x-openmausbot-desktop-owner": fx.ownerCapability } });
const makeHome = () => createHomeWindow({
...(clean ? { clean } : {}),
journal: () => (moves.moved ? { v: 1, phase: "done", cloud: { origin: cloudOrigin, account: ACCOUNT_ID, machine: cloudOrigin }, doneAt: Date.now() } : null),
frozen: async () => (moves.moved ? (await (clean ? clean.realCopy(ownCopy) : ownCopy)("/api/move/freeze")).json() : { frozen: false }),
// The window's Electron session: its own resolver and host cache, for My Cloud's name.
hosts: () => ({
clearHostResolverCache: async () => { hostCache.cleared++; },
resolveHost: async (host: string) => {
if (network.nameMissing && host === new URL(cloudOrigin).hostname) throw new Error("net::ERR_NAME_NOT_RESOLVED");
return { endpoints: [{ address: "127.0.0.1", family: "ipv4" }] };
},
}),
account: () => client as never,
window: () => (win.destroyed ? null : win) as never,
ensureWindow: () => {},
localOrigin: () => localOrigin,
cookieFetch: cookieFetch as typeof fetch,
power,
go: (url: string, origin: string | null, place: unknown) => { activate(origin, place); return win.loadURL(url).catch(() => {}); },
remembered: homePlaces.remembered, remember: homePlaces.remember, left: homePlaces.left, drop: homePlaces.drop,
showLocal: (leaving: boolean) => {
if (!leaving && /^https?:/.test(win.url)) return undefined;
if (leaving && environments.activeEnvironment(envState)) persist(environments.withActive(envState, environments.LOCAL_ID));
return win.loadURL(`${localOrigin}/`).catch(() => {});
},
splash: () => (world.splash && !world.splash.destroyed ? { status: (text: string) => startup?.status(text) } : null),
publish: (view: unknown) => { if (new URL(win.url.startsWith("http") ? win.url : "about:blank").origin === localOrigin) win.webContents.send("home:state-changed", view); },
versionEveryMs, quietMs,
log: () => {},
});
// A launch of the app: its home window as main makes it, knowing nothing of the last run.
const launchHome = () => {
const made = makeHome();
homeRef = made;
installHomeWindowIpc({ ipcMain, homeWindow: made, cloudPage: (event: any) => (made.homePage(event) ? "cloud" : null) });
return made;
};
let home = launchHome();
responded = (details) => homeRef!.responded(details);
win.webContents.on("did-navigate", (_event: unknown, url: string) => homeRef!.navigated(url));
win.webContents.on("did-fail-load", (_event: unknown, _code: number, _description: string, url: string) => homeRef!.failed(url));
cleanup.unshift(() => homeRef!.close());
// main.mjs's own delivery of a link the OS opened: queued, then sent to the page that is home.
const start = MAIN.indexOf("/** To this computer's page, or to My Cloud's once it is home");
const end = MAIN.indexOf('app.on("open-url"', start);
const linkContext = vm.createContext({
homeWindow: home, rendererOrigin: () => localOrigin, activeRemote: () => null, environmentsState: { environments: [], activeId: "local" },
showHome: () => homeRef!.show(), workspaceMenuAction: (action: () => unknown) => action(), switchEnvironment: () => {}, LOCAL_ID: "local",
mainWindow: win, desktopTray: null, startupScreen: null, BrowserWindow: { getAllWindows: () => [win] }, activateExistingWindow: () => true,
chatLinkFrom, packageUrlFromDeepLink, pendingChatLink: null, pendingPackageInstallUrl: null, URL,
});
vm.runInContext(`${MAIN.slice(start, end)}; this.queueChatLink = queueChatLink; this.deliverChatLink = deliverChatLink;`, linkContext);
win.webContents.on("did-stop-loading", () => linkContext.deliverChatLink(win));
// main.mjs's rail: its list (railList, with railProfiles) and handlers, for the rail's own page in a tab of its own, as
// wide as the window's rail view.
// main.mjs's localProfiles: the registry beside the profiles' folders, the Trash a folder of the fixture's own, and what
// the server that runs still does asked as main asks it.
const trashDir = join(fx.root, "Trash");
const registry = profiles ? createProfileRegistry({ dataDir: () => fx.desktopDataDir }) : null;
const makeLocal = () => (clean && registry ? createLocalProfiles({ registry, clean, dataDir: () => fx.desktopDataDir,
home: () => (homeRef!.cloudOrigin() ? "cloud" : clean.marker().frozen ? null : "local"),
window: { openProfile: (id: string) => homeRef!.openProfile(id), profile: () => homeRef!.profile(), showCloud: () => homeRef!.show({ place: "cloud" }) },
showLocal: () => { homeRef!.cancel(); persist(environments.withActive(envState, environments.LOCAL_ID)); return win.loadURL(`${localOrigin}/`).catch(() => {}); },
onLocal: () => /^https?:/.test(win.url) && new URL(win.url).origin === localOrigin,
busy: async () => { const said = await (await ownCopy("/api/move/freeze")).json(); return typeof said?.busy === "string" ? { name: said.busy, what: said.what } : null; },
trash: async (dir: string) => { mkdirSync(trashDir, { recursive: true }); renameSync(dir, join(trashDir, `${Date.now()}-${dir.split(/[\\/]/).pop()}`)); },
reserved: () => "This Mac", remember: homePlaces.remember, changed: () => railHandlers?.changed() }) : null);
let localProfiles = makeLocal();
const railList = () => {
const settling = localProfiles?.settling() ?? null;
return railPlaces({ saved: envState, home: homeRef!.cloudOrigin(), mine: cloudOrigin, state: account.state,
profiles: localProfiles?.places({ activeLocal: envState.activeId === environments.LOCAL_ID }) ?? [], computerSettling: settling && settling.id === null ? settling.name : null });
};
let lending: ReturnType<typeof createComputerSharing> | null = null;
if (profiles) {
railRef = await TabWindow.open(cdp, preloadStandIn(ipcBase, localOrigin, "rail"));
await cdp.request("Emulation.setDeviceMetricsOverride", { width: 36, height: 800, deviceScaleFactor: 2, mobile: false }, railRef.sessionId);
await cdp.request("Emulation.setDefaultBackgroundColorOverride", { color: { r: 0, g: 0, b: 0, a: 0 } }, railRef.sessionId);
railHandlers = installCloudRail({
ipcMain, guard: (handler: any) => handler, trusted: () => true, lists: (event: any) => event.sender === railRef!.webContents, beside: () => true,
places: railList, account: () => null, clipboard: { writeText: () => {} }, openCloud: async () => {},
add: { choices: () => ({ cloud: false, link: true, address: false }), run: () => {} },
targets: () => [win.webContents, railRef!.webContents],
// main.mjs's switchEnvironment: This computer (its own copy, or back from a workspace), or My Cloud shown again.
open: async (id: string) => {
if (id === environments.LOCAL_ID && clean!.profile()) { await (homeRef!.cloudOrigin() ? localProfiles!.open(clean!.profile()!) : localProfiles!.computer()); railHandlers?.changed(); return; }
homeRef!.cancel();
if (id === environments.LOCAL_ID) { persist(environments.withActive(envState, environments.LOCAL_ID)); await win.loadURL(`${localOrigin}/`).catch(() => {}); return; }
const entry = envState.environments.find((candidate: any) => candidate.id === id);
if (entry?.origin === homeRef!.cloudOrigin()) return homeRef!.show({ place: "cloud" }).then(() => railHandlers?.changed());
throw new Error("This harness opens My Cloud and this computer's own places only");
},
openProfile: async (id: string) => {
const opened = await localProfiles!.open(id);
railHandlers?.changed();
if (opened === false) throw new Error("This computer's own place didn't open.");
},
local: { creatable: () => localProfiles!.creatable(), create: (input: any) => localProfiles!.create(input), rename: (id: string, name: string) => localProfiles!.rename(id, name),
recolor: (id: string, color: string | null) => localProfiles!.recolor(id, color), remove: (id: string) => localProfiles!.remove(id), cancel: () => localProfiles!.cancel() } as never,
});
win.webContents.on("did-navigate", () => railHandlers?.changed());
await railRef.loadURL(`${localOrigin}/rail`);
// This computer, lent to My Cloud on the window's own session, as main's sharingController lends it.
const lentHome = mkdtempSync(join(tmpdir(), "omb-profile-lent-"));
cleanup.push(() => rmSync(lentHome, { recursive: true, force: true }));
const target = createLendingTarget({ account: () => client as never, clean, environments: () => envState.environments });
lending = createComputerSharing({
file: join(lentHome, "computer-sharing.json"), home: lentHome, fetch: cookieFetch as typeof fetch, environments: () => envState.environments,
cloud: target.cloud, myCloud: target.environment, ownClouds: target.places, screen: () => false, cuaConnection: async () => null,
linkHeaders: async (env: { origin: string }) => ({ cookie: ((await cdp.request("Network.getCookies", { urls: [env.origin] }, win.sessionId)).cookies as Array<{ name: string; value: string }>)
.map((entry) => `${entry.name}=${entry.value}`).join("; ") }),
});
cleanup.unshift(() => lending?.close());
}
let startup: ReturnType<typeof createStartupScreen> | null = null;
return {
rail: railRef, railList, clean, lending, running: () => running, registry, trashDir,
get profiles() { return localProfiles; },
railCovers: () => railCovers,
async setSize(width: number, height: number) {
Object.assign(size, { width, height });
await cdp.request("Emulation.setDeviceMetricsOverride", { width, height, deviceScaleFactor: 2, mobile: false }, win.sessionId);
if (railRef) await cdp.request("Emulation.setDeviceMetricsOverride", { width: railCovers ? width : 36, height, deviceScaleFactor: 2, mobile: false }, railRef.sessionId);
},
async theme(dark: boolean) {
for (const tab of [win, railRef].filter(Boolean) as TabWindow[]) {
await cdp.request("Emulation.setEmulatedMedia", { features: [{ name: "prefers-color-scheme", value: dark ? "dark" : "light" }] }, tab.sessionId);
// The app follows the OS's look once its skin is System; a page reads that choice as it loads.
if (await tab.evaluate("localStorage.getItem('omb-skin') === 'system'").catch(() => true)) continue;
await tab.evaluate("localStorage.setItem('omb-skin', 'system')").catch(() => {});
await cdp.request("Page.reload", {}, tab.sessionId).catch(() => {});
}
await new Promise((resolve) => setTimeout(resolve, 3_000));
},
async restartApp(whileClosed?: () => unknown) {
homeRef!.close();
// A quit stops this computer's server as main's before-quit does, and the next launch starts it on the data folder.
await fx.relaunch({ kill: false });
running = fx.desktopDataDir;
await whileClosed?.();
home = launchHome();
localProfiles = makeLocal();
await openStartPlace({ home, places: homePlaces, profiles: localProfiles, server: async () => false });
if (railRef) await railRef.loadURL(`${localOrigin}/rail`);
},
cloudOrigin, localOrigin, teamOrigin, otherOrigin, window: win, get home() { return homeRef!; }, account, network, admin, cloudRequests, notifications, hostCache,
get moved() { return moves.moved; },
set moved(value: boolean) { moves.moved = value; },
places: homePlaces, environments: () => envState,
menu: () => environments.workspaceMenuTemplate(envState, { onSwitch() {}, onConnect() {}, onForget() {}, homeOrigin: homeRef!.cloudOrigin() }),
async sync() { homePlaces.sync(account.state); await homeRef!.changed(); },
get splash() { return world.splash; },
async launch() {
const splashTab = await TabWindow.open(cdp);
world.splash = splashTab;
// The startup screen makes its own window: here, the tab made for it.
class SplashWindow extends TabWindow { constructor() { super(cdp, splashTab.targetId, splashTab.sessionId); world.splash = this; } }
splashTab.removeAllListeners();
startup = createStartupScreen({ BrowserWindow: SplashWindow as never, iconPath: SPLASH_ICON, platform: "darwin", isQuitting: () => false, onQuit: () => {}, onFinished: () => { startup = null; } });
await startup.ready;
startup.attach(win as never, { maximized: false });
await homeRef!.show();
},
openLink: (link) => linkContext.queueChatLink(link),
async cloudCookies() { return (await cdp.request("Network.getCookies", { urls: [cloudOrigin] }, win.sessionId)).cookies; },
async close() { for (const step of cleanup) await Promise.resolve().then(step).catch(() => {}); },
};
}
export function shotsDir(fallback: string): string {
const dir = process.env.OMB_ONE_WORKSPACE_SHOTS ?? join(fallback, "shots");
mkdirSync(dir, { recursive: true });
return dir;
}