@celljs/ta-computer-use 0.0.0-stage → 4.8.0

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@celljs/ta-computer-use",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "4.8.0",
+  "description": "A pi package for Ta: the desktop apps of this computer, used in the background through Cua Driver, which starts only when the agent first needs it",
+  "keywords": [
+    "pi-package"
+  ],
+  "homepage": "https://github.com/cellbang/cell",
+  "bugs": {
+    "url": "https://github.com/cellbang/cell/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cellbang/cell.git"
+  },
+  "license": "MIT",
+  "files": [
+    "esm",
+    "extension",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -b && bun build src/extension.ts --format esm --target node --outfile extension/index.mjs",
+    "clean": "rm -rf lib extension *.tsbuildinfo",
+    "test": "bun test ./lib",
+    "watch": "tsc -b -w --preserveWatchOutput"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^1.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "./extension/index.mjs"
+    ]
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./lib/*.js": {
+      "import": "./esm/*.js",
+      "default": "./lib/*.js"
+    },
+    "./lib/*": {
+      "import": "./esm/*.js",
+      "default": "./lib/*.js"
+    },
+    "./*": "./*"
+  }
+}

package/src/cua-driver-access.spec.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'bun:test';
+import { askMac, CuaDriverAccess, type CuaDriverRun, NO_ACCESSIBILITY, NO_SCREEN_RECORDING } from './cua-driver-access';
+
+const permissions = (accessibility: boolean, screenRecording: boolean): CuaDriverRun => ({
+    code: 0,
+    stdout: JSON.stringify({ accessibility, screen_recording: screenRecording, source: { attribution: 'driver-daemon' } }),
+    stderr: '',
+});
+const PENDING: CuaDriverRun = { code: 1, stdout: '', stderr: 'permissions_pending: macOS Accessibility or Screen Recording permission is still pending' };
+
+/** A Mac whose daemon answers `answers` in turn, the last one again. */
+function mac(answers: CuaDriverRun[], waitMs = 1000, graceMs = 0) {
+    const calls: string[][] = [];
+    const opened: string[] = [];
+    const notes: string[] = [];
+    let looks = 0;
+    const access = new CuaDriverAccess('/A/cua-driver', {
+        platform: 'darwin',
+        socket: '/c/s.sock',
+        env: { X: '1' },
+        pollMs: 1,
+        waitMs,
+        graceMs,
+        run: async (_program, args, _timeout, env) => {
+            calls.push([...args, String(env?.X)]);
+            return answers[Math.min(calls.length - 1, answers.length - 1)];
+        },
+        openSettings: pane => opened.push(pane),
+        beforeLook: async () => {
+            looks++;
+        },
+    });
+    return { access, calls, opened, notes, notify: (text: string) => notes.push(text), looks: () => looks };
+}
+
+describe('askMac', () => {
+    it("speaks the language of Ta's pages", () => {
+        expect(askMac({ TA_LANGUAGE: 'zh-CN', LANG: 'en_US.UTF-8' })).toContain('辅助功能');
+        expect(askMac({ LANG: 'en_US.UTF-8' })).toContain('Accessibility');
+    });
+});
+
+describe('CuaDriverAccess on macOS', () => {
+    it('goes on at once when both permissions are on', async () => {
+        const m = mac([permissions(true, true)]);
+        expect(await m.access.check(m.notify)).toEqual({ ready: true, notes: [], known: true });
+        expect(m.calls).toEqual([['call', 'check_permissions', '{"prompt":false}', '--socket', '/c/s.sock', '1']]);
+        expect(m.notes).toEqual([]);
+    });
+
+    it("while the driver's guide is open, tells the user and waits until both are on", async () => {
+        // The daemon answers nothing but permissions_pending while its guide is open, at either step.
+        const m = mac([PENDING, PENDING, PENDING, permissions(true, true)]);
+        expect(await m.access.check(m.notify)).toEqual({ ready: true, notes: [], known: true });
+        expect(m.notes).toEqual([askMac()]);
+        expect(m.opened).toEqual([]);
+        expect(m.looks()).toBe(3);
+    });
+
+    it('says nothing while a daemon that just started settles', async () => {
+        const m = mac([PENDING, PENDING, permissions(true, true)], 1000, 1000);
+        expect(await m.access.check(m.notify)).toEqual({ ready: true, notes: [], known: true });
+        expect(m.notes).toEqual([]);
+    });
+
+    it('opens System Settings when the guide was closed, and goes on without Screen Recording', async () => {
+        const m = mac([permissions(false, false), permissions(true, false)]);
+        expect(await m.access.check(m.notify)).toEqual({ ready: true, notes: [NO_SCREEN_RECORDING], known: true });
+        expect(m.opened).toEqual(['Privacy_Accessibility']);
+        const s = mac([permissions(true, false)]);
+        expect(await s.access.check(s.notify)).toEqual({ ready: true, notes: [NO_SCREEN_RECORDING], known: true });
+        expect(s.opened).toEqual(['Privacy_ScreenCapture']);
+    });
+
+    it('stops a call without Accessibility after the wait, or when stopped', async () => {
+        const m = mac([PENDING], 20);
+        expect(await m.access.check(m.notify)).toEqual({ ready: false, reason: NO_ACCESSIBILITY });
+        const stop = new AbortController();
+        const s = mac([PENDING], 60_000);
+        const started = Date.now();
+        setTimeout(() => stop.abort(), 20);
+        expect(await s.access.check(s.notify, stop.signal)).toMatchObject({ ready: false });
+        expect(Date.now() - started).toBeLessThan(1000);
+    });
+
+    it('does not stop Ta when the daemon cannot tell', async () => {
+        const m = mac([{ code: 1, stdout: '', stderr: 'no Cua Driver daemon listening' }]);
+        expect(await m.access.check(m.notify)).toEqual({ ready: true, notes: [], known: false });
+    });
+});
+
+describe('CuaDriverAccess on Linux and Windows', () => {
+    const doctor = (probes: object[]): CuaDriverRun => ({ code: 0, stdout: JSON.stringify({ ok: true, probes }), stderr: '' });
+    const check = (result: CuaDriverRun, platform: NodeJS.Platform = 'linux') =>
+        new CuaDriverAccess('/c/cua-driver', {
+            platform,
+            run: async (_p, args) => (args[0] === 'doctor' ? result : { code: 1, stdout: '', stderr: '' }),
+        }).check(() => undefined);
+
+    it('goes on when the desktop is reachable, with its warnings for the user', async () => {
+        expect(
+            await check(
+                doctor([
+                    { label: 'binary', status: 'ok' },
+                    { label: 'telemetry', status: 'warn', message: 'on' },
+                ]),
+            ),
+        ).toEqual({ ready: true, notes: [], known: true });
+        expect(
+            await check(
+                doctor([
+                    {
+                        label: 'AT-SPI',
+                        status: 'warn',
+                        message: 'accessibility bus not reachable',
+                        detail: 'install at-spi2-core and ensure the user session has D-Bus running',
+                    },
+                ]),
+            ),
+        ).toEqual({
+            ready: true,
+            notes: ['Cua Driver: AT-SPI: accessibility bus not reachable — install at-spi2-core and ensure the user session has D-Bus running'],
+            known: true,
+        });
+    });
+
+    it('stops a call without a desktop session or when a probe fails', async () => {
+        const noDisplay = await check(doctor([{ label: 'display server', status: 'warn', message: 'neither DISPLAY nor WAYLAND_DISPLAY set' }]));
+        expect(noDisplay).toEqual({ ready: false, reason: 'Cua Driver cannot use the desktop: display server: neither DISPLAY nor WAYLAND_DISPLAY set' });
+        expect(await check(doctor([{ label: 'session', status: 'error', message: 'session 0' }]), 'win32')).toMatchObject({ ready: false });
+    });
+
+    it('says which library is missing, and how to install them on Debian or Ubuntu', async () => {
+        const result = await check({
+            code: 127,
+            stdout: '',
+            stderr: './cua-driver: error while loading shared libraries: libX11.so.6: cannot open shared object file',
+        });
+        expect(result).toMatchObject({ ready: false });
+        expect((result as { reason: string }).reason).toContain('libX11.so.6');
+        expect((result as { reason: string }).reason).toContain('sudo apt install');
+    });
+
+    it('does not stop Ta when the report cannot be read', async () => {
+        expect(await check({ code: -1, stdout: '', stderr: '' })).toEqual({ ready: true, notes: [], known: true });
+    });
+});

package/src/cua-driver-access.ts

@@ -0,0 +1,188 @@
+import { execFile } from 'node:child_process';
+
+/** What a run of the program gave; `code` is -1 when it could not run or took too long. */
+export interface CuaDriverRun {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+
+export type CuaDriverRunner = (program: string, args: string[], timeoutMs: number, env?: Readonly<Record<string, string>>) => Promise<CuaDriverRun>;
+
+/**
+ * Whether Ta may go on with a call that uses Cua Driver; `notes` are for the user, once. `known` is false
+ * when the system could not tell (the daemon of the user's own install is not running yet): ask again next time.
+ */
+export type CuaDriverReadiness = { ready: true; notes: string[]; known: boolean } | { ready: false; reason: string };
+
+/** The two permissions of macOS, as `check_permissions` answers; `pending` while its guide is still open. */
+export interface MacPermissions {
+    accessibility: boolean;
+    screenRecording: boolean;
+    pending: boolean;
+}
+
+export interface CuaDriverAccessOptions {
+    platform: NodeJS.Platform;
+    /** The socket of the daemon to ask, on macOS; without one, the program's default daemon. */
+    socket?: string;
+    /** Added to the environment of each run. */
+    env?: Readonly<Record<string, string>>;
+    run?: CuaDriverRunner;
+    /** Opens a pane of System Settings, on macOS. */
+    openSettings?: (pane: 'Privacy_Accessibility' | 'Privacy_ScreenCapture') => void;
+    /** Before each look while waiting, on macOS: the daemon of Ta Desktop restarts if it quit for a permission. */
+    beforeLook?: () => Promise<void>;
+    pollMs?: number;
+    waitMs?: number;
+    graceMs?: number;
+}
+
+const CHECK_TIMEOUT_MS = 5000;
+const DOCTOR_TIMEOUT_MS = 15000;
+const POLL_MS = 1000;
+/** A daemon that just started answers permissions_pending for a few hundred ms even when it has both. */
+const GRACE_MS = 3000;
+const GRACE_POLL_MS = 100;
+/** How long a call waits for the user to give the permissions of macOS. */
+const WAIT_MS = 3 * 60 * 1000;
+/** The probes of `cua-driver doctor` about reaching the desktop, which the user can fix. */
+const DESKTOP_PROBES = /display|x11|wayland|at-spi|accessib|session|desktop|automation|uia/i;
+const MISSING_LIBRARY = /error while loading shared libraries: (\S+?):/;
+
+/** What the user reads while Ta waits for the permissions: in the language of Ta's pages (`TA_LANGUAGE`) or the computer's. */
+export function askMac(env: NodeJS.ProcessEnv = process.env): string {
+    return /^zh/i.test(env.TA_LANGUAGE || env.LC_ALL || env.LANG || '')
+        ? 'Ta 正在请 macOS 允许 Cua Driver 使用这台 Mac：请在 Cua Driver 打开的窗口或“系统设置”里，打开“辅助功能”（用于点击和输入）和“屏幕录制”（用于查看窗口）中的 Cua Driver。开好后 Ta 会自动继续；点“停止”可放弃。'
+        : 'Ta is asking macOS to let Cua Driver use this Mac: turn Cua Driver on under Accessibility (to click and type) and Screen Recording (to see windows), in the window Cua Driver opened or in System Settings. Ta goes on by itself once you have; Stop gives up.';
+}
+export const NO_ACCESSIBILITY =
+    'Cua Driver has no Accessibility permission of macOS, which it needs to read and use apps: ask the user to turn Cua Driver on in System Settings → Privacy & Security → Accessibility (`/computer-use` in Ta opens it), then try again.';
+export const NO_SCREEN_RECORDING =
+    'Cua Driver has no Screen Recording permission of macOS: it reads and uses apps, but takes no screenshots. Turn it on in System Settings → Privacy & Security → Screen & System Audio Recording.';
+
+/**
+ * Checks what the system needs before Ta first uses Cua Driver, and asks the user for it, so that a
+ * missing permission is something the user is told how to fix and not a failed call.
+ * - macOS: the Accessibility and Screen Recording permissions of CuaDriver.app. A daemon without them
+ *   opens its own guide; Ta tells the user, waits while they turn the switches on, and goes on.
+ * - Linux and Windows: no permission, but a desktop session; Linux also needs the accessibility bus and
+ *   some X11 libraries. `cua-driver doctor` says what is missing.
+ */
+export class CuaDriverAccess {
+    protected readonly run: CuaDriverRunner;
+
+    constructor(
+        readonly program: string,
+        protected readonly options: CuaDriverAccessOptions,
+    ) {
+        this.run = options.run ?? runProgram;
+    }
+
+    check(notify: (message: string) => void, signal?: AbortSignal): Promise<CuaDriverReadiness> {
+        return this.options.platform === 'darwin' ? this.checkMac(notify, signal) : this.checkDesktop();
+    }
+
+    /** What the daemon says; undefined when it cannot tell, which does not stop Ta. */
+    async permissions(): Promise<MacPermissions | undefined> {
+        const socket = this.options.socket ? ['--socket', this.options.socket] : [];
+        const result = await this.run(this.program, ['call', 'check_permissions', '{"prompt":false}', ...socket], CHECK_TIMEOUT_MS, this.options.env);
+        return CuaDriverAccess.parsePermissions(result);
+    }
+
+    protected async checkMac(notify: (message: string) => void, signal?: AbortSignal): Promise<CuaDriverReadiness> {
+        let state = await this.permissions();
+        const grace = Date.now() + (this.options.graceMs ?? GRACE_MS);
+        while (state?.pending && Date.now() < grace && !signal?.aborted) {
+            await sleep(GRACE_POLL_MS, signal);
+            state = await this.permissions();
+        }
+        if (!state || (state.accessibility && state.screenRecording)) {
+            return { ready: true, notes: [], known: state !== undefined };
+        }
+        notify(askMac());
+        if (!state.pending) {
+            // The guide was closed before: System Settings, where Cua Driver is listed since it asked once.
+            this.options.openSettings?.(state.accessibility ? 'Privacy_ScreenCapture' : 'Privacy_Accessibility');
+        }
+        const deadline = Date.now() + (this.options.waitMs ?? WAIT_MS);
+        // Until both are on, or the guide is closed with Accessibility on: Screen Recording is optional.
+        while (!signal?.aborted && Date.now() < deadline && !(state?.accessibility && (state.screenRecording || !state.pending))) {
+            await sleep(this.options.pollMs ?? POLL_MS, signal);
+            await this.options.beforeLook?.();
+            state = (await this.permissions()) ?? state;
+        }
+        if (state?.accessibility) {
+            return { ready: true, notes: state.screenRecording ? [] : [NO_SCREEN_RECORDING], known: true };
+        }
+        return { ready: false, reason: signal?.aborted ? 'Stopped while waiting for the permissions of macOS.' : NO_ACCESSIBILITY };
+    }
+
+    protected async checkDesktop(): Promise<CuaDriverReadiness> {
+        const result = await this.run(this.program, ['doctor', '--json'], DOCTOR_TIMEOUT_MS, this.options.env);
+        return CuaDriverAccess.parseDoctor(result, this.options.platform);
+    }
+}
+
+export namespace CuaDriverAccess {
+    export function parsePermissions(result: CuaDriverRun): MacPermissions | undefined {
+        if (`${result.stdout}${result.stderr}`.includes('permissions_pending')) {
+            return { accessibility: false, screenRecording: false, pending: true };
+        }
+        try {
+            const answer = JSON.parse(result.stdout) as { accessibility?: unknown; screen_recording?: unknown };
+            if (typeof answer.accessibility !== 'boolean') {
+                return undefined;
+            }
+            return { accessibility: answer.accessibility, screenRecording: answer.screen_recording === true, pending: false };
+        } catch {
+            return undefined;
+        }
+    }
+
+    /**
+     * Not ready when the program cannot start (a library is missing), when a probe fails, or when there is
+     * no desktop session; the other warnings about the desktop are notes. A report it cannot read does not stop Ta.
+     */
+    export function parseDoctor(result: CuaDriverRun, platform: NodeJS.Platform): CuaDriverReadiness {
+        const library = MISSING_LIBRARY.exec(result.stderr)?.[1];
+        if (library) {
+            const install = platform === 'linux' ? ' On Debian or Ubuntu: `sudo apt install libx11-6 libxi6 libxkbcommon0 at-spi2-core`.' : '';
+            return { ready: false, reason: `Cua Driver cannot start: the system has no ${library}.${install}` };
+        }
+        let probes: { label?: string; status?: string; message?: string; detail?: string }[];
+        try {
+            probes = (JSON.parse(result.stdout) as { probes?: typeof probes }).probes ?? [];
+        } catch {
+            return { ready: true, notes: [], known: true };
+        }
+        const text = (probe: (typeof probes)[number]) => [`${probe.label}: ${probe.message}`, probe.detail].filter(Boolean).join(' — ');
+        const failed = probes.filter(probe => probe.status === 'error' || (probe.status === 'warn' && /display server/i.test(probe.label ?? '')));
+        if (failed.length > 0) {
+            return { ready: false, reason: `Cua Driver cannot use the desktop: ${failed.map(text).join('; ')}` };
+        }
+        const warned = probes.filter(probe => probe.status === 'warn' && DESKTOP_PROBES.test(probe.label ?? ''));
+        return { ready: true, notes: warned.map(probe => `Cua Driver: ${text(probe)}`), known: true };
+    }
+}
+
+function runProgram(program: string, args: string[], timeoutMs: number, env?: Readonly<Record<string, string>>): Promise<CuaDriverRun> {
+    return new Promise(resolve => {
+        execFile(program, args, { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, ...env } }, (error, stdout, stderr) => {
+            const code = error ? (typeof error.code === 'number' ? error.code : -1) : 0;
+            resolve({ code, stdout: String(stdout), stderr: String(stderr) });
+        });
+    });
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+    return new Promise(resolve => {
+        const timer = setTimeout(done, ms);
+        signal?.addEventListener('abort', done, { once: true });
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', done);
+            resolve();
+        }
+    });
+}

package/src/cua-driver-daemon.spec.ts

@@ -0,0 +1,168 @@
+import { afterEach, describe, expect, it } from 'bun:test';
+import { type ChildProcess, spawn } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CuaDriverDaemon } from './cua-driver-daemon';
+
+/** Stands in for `cua-driver serve --socket <s> --pid-file <p>`. */
+const FAKE = `
+const [, , , , socket, , pidFile] = process.argv;
+require('node:fs').writeFileSync(pidFile, String(process.pid));
+require('node:net').createServer(c => c.end()).listen(socket);
+process.on('SIGTERM', () => process.exit(0));
+`;
+
+function exited(child: ChildProcess): Promise<unknown> {
+    return child.exitCode !== null || child.signalCode !== null ? Promise.resolve() : new Promise(resolve => child.once('exit', resolve));
+}
+
+describe.skipIf(process.platform === 'win32')('CuaDriverDaemon', () => {
+    const children: ChildProcess[] = [];
+    let dir: string;
+
+    afterEach(() => {
+        for (const child of children) {
+            child.kill('SIGKILL');
+        }
+        children.length = 0;
+        rmSync(dir, { recursive: true, force: true });
+    });
+
+    /** An app whose program is the fake; `launches` runs `other`'s program instead when given, as LaunchServices may. */
+    function daemon(other?: string): { daemon: CuaDriverDaemon; launches: string[][]; app: string } {
+        dir = mkdtempSync(join(tmpdir(), 'ta-cua-'));
+        const app = fakeApp(join(dir, 'A'));
+        const runs = other ? fakeApp(join(dir, other)) : app;
+        const launches: string[][] = [];
+        return {
+            app,
+            launches,
+            daemon: new CuaDriverDaemon(app, {
+                dir: join(dir, 'cache'),
+                env: { CUA_DRIVER_RS_TELEMETRY_ENABLED: '0' },
+                launch: async (target, args, env) => {
+                    launches.push([target, ...args, JSON.stringify(env)]);
+                    children.push(spawn('node', [join(runs, 'Contents/MacOS/cua-driver'), ...args], { stdio: 'ignore' }));
+                },
+            }),
+        };
+    }
+
+    function fakeApp(at: string): string {
+        const app = join(at, 'CuaDriver.app');
+        mkdirSync(join(app, 'Contents/MacOS'), { recursive: true });
+        writeFileSync(join(app, 'Contents/MacOS/cua-driver'), FAKE);
+        return app;
+    }
+
+    it('starts it once on its own socket, uses it while it runs, and stops it', async () => {
+        const { daemon: driver, launches } = daemon();
+        expect(await driver.alive()).toBe(false);
+        // A socket file left behind by one that was killed.
+        writeFileSync(join(dir, 'stale'), '');
+        await Promise.all([driver.ensure(), driver.ensure()]);
+        await driver.ensure();
+        expect(launches).toEqual([[driver.app, 'serve', '--socket', driver.socket, '--pid-file', driver.pidFile, '{"CUA_DRIVER_RS_TELEMETRY_ENABLED":"0"}']]);
+        expect(await driver.alive()).toBe(true);
+        driver.stop();
+        await exited(children[0]);
+        expect(await driver.alive()).toBe(false);
+        await driver.ensure();
+        expect(launches.length).toBe(2);
+    });
+
+    it('does not stop one it did not start', async () => {
+        const { daemon: first } = daemon();
+        await first.ensure();
+        const second = new CuaDriverDaemon(first.app, {
+            dir: join(dir, 'cache'),
+            launch: async () => {
+                throw new Error('not again');
+            },
+        });
+        await second.ensure();
+        second.stop();
+        expect(await first.alive()).toBe(true);
+        expect(existsSync(first.pidFile)).toBe(true);
+    });
+
+    it('stops another copy of the app that macOS started instead, and says what to do', async () => {
+        const { daemon: driver } = daemon('B');
+        await expect(driver.ensure()).rejects.toThrow('doctor --fix');
+        await exited(children[0]);
+        expect(await driver.alive()).toBe(false);
+    });
+
+    it('replaces a running daemon of another copy, which a relay of this one would not understand', async () => {
+        const { daemon: first } = daemon();
+        await first.ensure();
+        const firstPid = Number(readFileSync(first.pidFile, 'utf8'));
+        const launches: string[] = [];
+        class Other extends CuaDriverDaemon {
+            protected override identify() {
+                return Promise.resolve(launches.length === 0 ? { executable: '/Other/CuaDriver.app/Contents/MacOS/cua-driver', pid: firstPid } : undefined);
+            }
+        }
+        const second = new Other(first.app, {
+            dir: first.dir,
+            launch: async (_app, args) => {
+                launches.push('launch');
+                children.push(spawn('node', [join(first.app, 'Contents/MacOS/cua-driver'), ...args], { stdio: 'ignore' }));
+            },
+        });
+        await second.ensure();
+        await exited(children[0]);
+        expect(launches).toEqual(['launch']);
+        expect(await second.alive()).toBe(true);
+        second.stop();
+    });
+
+    it("runs an app inside another app's bundle from its copy outside, by version, and drops older copies", async () => {
+        dir = mkdtempSync(join(tmpdir(), 'ta-cua-'));
+        const app = fakeApp(join(dir, 'Ta.app/Contents/Resources/cua-driver'));
+        writeFileSync(join(app, 'Contents/Info.plist'), '<plist><dict><key>CFBundleVersion</key>\n<string>0.47.5</string></dict></plist>');
+        const stageDir = join(dir, 'stage');
+        mkdirSync(join(stageDir, '0.40.0/CuaDriver.app'), { recursive: true });
+        const launched: string[] = [];
+        const driver = new CuaDriverDaemon(app, {
+            dir: join(dir, 'cache'),
+            stageDir,
+            launch: async (target, args) => {
+                launched.push(target);
+                children.push(spawn('node', [join(target, 'Contents/MacOS/cua-driver'), ...args], { stdio: 'ignore' }));
+            },
+        });
+        expect(driver.app).toBe(join(stageDir, '0.47.5', 'CuaDriver.app'));
+        await driver.ensure();
+        expect(launched).toEqual([driver.app]);
+        expect(readFileSync(join(driver.app, 'Contents/MacOS/cua-driver'), 'utf8')).toBe(FAKE);
+        expect(existsSync(join(stageDir, '0.40.0'))).toBe(false);
+        expect(CuaDriverDaemon.nested('/Applications/CuaDriver.app')).toBe(false);
+        driver.stop();
+    });
+
+    it('stops by itself when unused', async () => {
+        const { daemon: driver } = daemon();
+        const idle = new CuaDriverDaemon(driver.app, {
+            dir: driver.dir,
+            idleMs: 50,
+            launch: (driver as unknown as { launch: CuaDriverDaemon['ensure'] }).launch as never,
+        });
+        await idle.ensure();
+        expect(await idle.alive()).toBe(true);
+        await exited(children[0]);
+        expect(await idle.alive()).toBe(false);
+    });
+
+    it('says so when it does not start', async () => {
+        dir = mkdtempSync(join(tmpdir(), 'ta-cua-'));
+        const driver = new CuaDriverDaemon(join(dir, 'CuaDriver.app'), {
+            dir,
+            launch: async () => {
+                throw new Error('LSOpenURLsWithRole() failed');
+            },
+        });
+        await expect(driver.ensure()).rejects.toThrow('LSOpenURLsWithRole');
+    });
+});