linkshell-cli 0.8.0 → 0.8.2

package/dist/host/src/input-helper.js.map

@@ -1 +1 @@
-{"version":3,"file":"input-helper.js","sourceRoot":"","sources":["../../../../host/src/input-helper.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,6EAA6E;AAC7E,+EAA+E;AAC/E,2EAA2E;AAC3E,kEAAkE;AAElE,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyM5C,CAAC"}
+{"version":3,"file":"input-helper.js","sourceRoot":"","sources":["../../../../host/src/input-helper.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+CAA+C;AAC/C,EAAE;AACF,wEAAwE;AACxE,8EAA8E;AAC9E,0EAA0E;AAC1E,uEAAuE;AACvE,+EAA+E;AAC/E,8EAA8E;AAC9E,wDAAwD;AAExD,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwiB5C,CAAC"}

package/dist/host/src/input.d.ts

@@ -62,12 +62,12 @@ export declare const inputEvent: z.ZodDiscriminatedUnion<"t", [z.ZodObject<{
     k: z.ZodString;
     m: z.ZodOptional<z.ZodArray<z.ZodEnum<["cmd", "shift", "alt", "ctrl"]>, "many">>;
 }, "strip", z.ZodTypeAny, {
-    k: string;
     t: "key";
+    k: string;
     m?: ("shift" | "cmd" | "alt" | "ctrl")[] | undefined;
 }, {
-    k: string;
     t: "key";
+    k: string;
     m?: ("shift" | "cmd" | "alt" | "ctrl")[] | undefined;
 }>, z.ZodObject<{
     t: z.ZodLiteral<"text">;
@@ -86,9 +86,11 @@ export declare const inputEvent: z.ZodDiscriminatedUnion<"t", [z.ZodObject<{
     t: "prompt";
 }>]>;
 export type InputEvent = z.infer<typeof inputEvent>;
+/** `app` is the name the system's privacy settings list: the one to allow. */
 export type ControlState = {
     available: true;
     trusted: boolean;
+    app?: string;
 } | {
     available: false;
     reason: string;
@@ -100,22 +102,94 @@ export interface InputListener {
     /** Dry runs only: the event that would have been posted. */
     posted?(event: Record<string, unknown>): void;
 }
-/** The compiled helper's path; built on first use, once per version of its source. */
+/** What the helper says of itself: what it may do, and under which app's name. */
+export interface HelperStatus {
+    trusted: boolean;
+    recording: boolean;
+    app: string;
+}
+/**
+ * The app as it came in the package, made runnable. Packing a package drops
+ * the program's permission to run (pnpm stores every file that isn't a `bin`
+ * as a plain one): it is given back here, and where the installation can't be
+ * written to (a root-owned one), a copy under the user's own directory is used.
+ * Neither touches the signature.
+ */
+export declare function usableApp(packaged: string, copyTo?: string): string | undefined;
+/** The signed app this package was made with, if it was. */
+export declare function shippedApp(): string | undefined;
+/** The helper compiled here; built on first use, once per version of its source. */
 export declare function inputHelper(log?: (message: string) => void): Promise<string>;
-/** One viewer's control of one display. */
+/**
+ * What this process itself (so: the host, and the capture it starts) is
+ * allowed to do, and under which app's name. `ask` has the system put its
+ * question for that permission, and opens the settings page for it.
+ */
+export declare function hostAccess(log: (message: string) => void, ask?: "recording" | "control"): Promise<HelperStatus>;
+type Route = (message: Record<string, unknown>) => void;
+declare class HelperApp {
+    private readonly app;
+    private readonly dryRun;
+    private readonly log;
+    private server?;
+    private socket?;
+    private opening?;
+    private status?;
+    private readonly routes;
+    private readonly watchers;
+    private waiting;
+    constructor(app: string, dryRun: boolean, log: (message: string) => void);
+    /** The app's end of the socket; opens the app when it isn't there. */
+    private link;
+    private open;
+    private adopt;
+    private write;
+    /** What the app may do. It says so as it connects; asked again, it looks again. */
+    access(): Promise<HelperStatus>;
+    /** The system's dialog and its settings page, for the app. */
+    ask(what?: "control" | "recording"): Promise<void>;
+    /**
+     * Has the app run a screen capture: as the app's child, the recording is the
+     * app's to be allowed. The picture comes down a socket of its own; the
+     * returned function ends the capture.
+     */
+    capture(exec: string, args: string[], on: {
+        data(chunk: Buffer): void;
+        exit(code: number, errors: string): void;
+    }): Promise<() => void>;
+    join(id: string, screen: number, route: Route, watcher: (status: HelperStatus) => void): Promise<void>;
+    send(id: string, event: InputEvent): void;
+    leave(id: string, watcher: (status: HelperStatus) => void): void;
+    /** The host is going: the app leaves when its socket closes. */
+    close(): void;
+}
+/** Ends the helper app, if this process opened one. */
+export declare function closeInputApp(): void;
+/** The signed app, opened when it isn't yet; undefined where the package has none. */
+export declare function inputApp(log: (message: string) => void): HelperApp | undefined;
+export type { HelperApp };
 export declare class InputControl {
     private readonly listener;
     private readonly log;
+    /** `app: false` keeps to a child process even when the package has the app (tests). */
     private readonly options;
     private child?;
+    private joined?;
     private stopped;
-    constructor(listener: InputListener, log: (message: string) => void, options?: {
+    private started;
+    constructor(listener: InputListener, log: (message: string) => void, 
+    /** `app: false` keeps to a child process even when the package has the app (tests). */
+    options?: {
         dryRun?: boolean;
+        app?: boolean;
     });
     /** Starts the helper for the display ffmpeg calls "Capture screen `screen`". Reports through the listener; never throws. */
     start(screen: number): Promise<void>;
+    private joinApp;
+    private spawn;
+    private heard;
     /** Passes on one event from the viewer; anything that is not one is dropped. */
     send(raw: unknown): void;
-    /** Ends the helper; on its way out it lets go of any button still held. */
+    /** Ends this viewer's control; on its way out the helper lets go of any button still held. */
     stop(): void;
 }

package/dist/host/src/input.js

@@ -1,18 +1,26 @@
 import { execFile, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { accessSync, chmodSync, constants, cpSync, existsSync, readFileSync, rmSync } from "node:fs";
 import { mkdir, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { createServer } from "node:net";
+import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { z } from "zod";
 import { INPUT_HELPER_SOURCE } from "./input-helper.js";
 // Controlling the computer from the phone: the screen viewer sends pointer and
 // key events down the same socket the picture comes up, and a small helper
-// posts them to the system. macOS only; the helper needs the Accessibility
-// permission, which the system grants to whatever started the host (the
-// terminal, as with Screen Recording).
+// posts them to the system. macOS only, and the system has to allow it
+// (Privacy & Security › Accessibility).
+//
+// A released package carries the helper as LinkShell.app, signed. The host has
+// the system open it, which makes it an app of its own: the permission is
+// asked for and kept under the name LinkShell, whichever terminal started the
+// host and however often the CLI is upgraded. A build without the app (a
+// checkout with no signing identity) compiles the same source on first use and
+// runs it as the host's child; the permission is then the terminal's.
 const run = promisify(execFile);
 const unit = z.number().min(0).max(1);
 const button = z.enum(["left", "right"]);
@@ -30,8 +38,69 @@ export const inputEvent = z.discriminatedUnion("t", [
     /** Have the system ask, on the computer, for the permission to control it. */
     z.object({ t: z.literal("prompt") }),
 ]);
+const dryRunByDefault = () => process.env.LINKSHELL_INPUT_DRY_RUN === "1";
+// ── Where the helper is ─────────────────────────────────────────────
+const home = () => process.env.LINKSHELL_HOME || join(homedir(), ".linkshell");
+const programOf = (app) => join(app, "Contents/MacOS/LinkShell");
+function runnable(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The app as it came in the package, made runnable. Packing a package drops
+ * the program's permission to run (pnpm stores every file that isn't a `bin`
+ * as a plain one): it is given back here, and where the installation can't be
+ * written to (a root-owned one), a copy under the user's own directory is used.
+ * Neither touches the signature.
+ */
+export function usableApp(packaged, copyTo = join(home(), "LinkShell.app")) {
+    if (runnable(programOf(packaged)))
+        return packaged;
+    try {
+        chmodSync(programOf(packaged), 0o755);
+        return packaged;
+    }
+    catch {
+        // Not ours to change: fall through to a copy.
+    }
+    try {
+        const plist = (app) => readFileSync(join(app, "Contents/Info.plist"), "utf8");
+        if (!existsSync(programOf(copyTo)) || plist(copyTo) !== plist(packaged)) {
+            rmSync(copyTo, { recursive: true, force: true });
+            cpSync(packaged, copyTo, { recursive: true });
+        }
+        chmodSync(programOf(copyTo), 0o755);
+        return copyTo;
+    }
+    catch {
+        return undefined;
+    }
+}
+let found;
+/** The signed app this package was made with, if it was. */
+export function shippedApp() {
+    if (process.platform !== "darwin" || process.env.LINKSHELL_INPUT_APP === "off")
+        return undefined;
+    if (found)
+        return found.app;
+    found = { app: undefined };
+    // Beside `dist` in a package (the host's own, or the CLI's, which compiles the host in); beside `src` in a checkout.
+    for (const relative of ["../../../helper/LinkShell.app", "../helper/LinkShell.app"]) {
+        const path = fileURLToPath(new URL(relative, import.meta.url));
+        if (existsSync(programOf(path))) {
+            found.app = usableApp(path);
+            break;
+        }
+    }
+    return found.app;
+}
 function binDir() {
-    return join(process.env.LINKSHELL_HOME || join(homedir(), ".linkshell"), "bin");
+    return join(home(), "bin");
 }
 async function build(log) {
     const hash = createHash("sha256").update(INPUT_HELPER_SOURCE).digest("hex").slice(0, 12);
@@ -67,46 +136,298 @@ async function build(log) {
     log("[screen] built the input helper");
     return path;
 }
-let helper;
-/** The compiled helper's path; built on first use, once per version of its source. */
+let compiled;
+/** The helper compiled here; built on first use, once per version of its source. */
 export function inputHelper(log = () => { }) {
-    helper ??= build(log).catch((error) => {
-        helper = undefined;
+    compiled ??= build(log).catch((error) => {
+        compiled = undefined;
         throw error;
     });
-    return helper;
+    return compiled;
 }
-/** One viewer's control of one display. */
+/** The helper to run as this process's child: the app's own program, or the one compiled here. */
+function childHelper(log, app) {
+    return app ? Promise.resolve(programOf(app)) : inputHelper(log);
+}
+function parse(line) {
+    try {
+        const message = JSON.parse(line);
+        return message && typeof message === "object" ? message : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function statusOf(message) {
+    return { trusted: message.trusted === true, recording: message.recording === true, app: typeof message.app === "string" ? message.app : "" };
+}
+/**
+ * What this process itself (so: the host, and the capture it starts) is
+ * allowed to do, and under which app's name. `ask` has the system put its
+ * question for that permission, and opens the settings page for it.
+ */
+export async function hostAccess(log, ask) {
+    const helper = await childHelper(log, shippedApp());
+    const { stdout } = await run(helper, [ask ? `--ask-${ask}` : "--status"], { timeout: 15_000 });
+    const message = parse(stdout.trim().split("\n").pop() ?? "");
+    if (!message)
+        throw new Error("the input helper gave no answer");
+    return statusOf(message);
+}
+class HelperApp {
+    app;
+    dryRun;
+    log;
+    server;
+    socket;
+    opening;
+    status;
+    routes = new Map();
+    watchers = new Set();
+    waiting = [];
+    constructor(app, dryRun, log) {
+        this.app = app;
+        this.dryRun = dryRun;
+        this.log = log;
+    }
+    /** The app's end of the socket; opens the app when it isn't there. */
+    link() {
+        if (this.socket && !this.socket.destroyed)
+            return Promise.resolve(this.socket);
+        this.opening ??= this.open().finally(() => (this.opening = undefined));
+        return this.opening;
+    }
+    open() {
+        // The app comes to us: a socket only this user can reach, in a directory of its own name.
+        const path = join(tmpdir(), `linkshell-input-${process.pid}-${randomBytes(4).toString("hex")}.sock`);
+        return new Promise((resolve, reject) => {
+            const server = createServer();
+            const fail = (error) => {
+                clearTimeout(timer);
+                server.close();
+                rmSync(path, { force: true });
+                reject(error);
+            };
+            const timer = setTimeout(() => fail(new Error("LinkShell.app did not start")), 15_000);
+            server.once("error", fail);
+            server.once("connection", (socket) => {
+                clearTimeout(timer);
+                // One app, one connection: nothing else gets in.
+                server.close();
+                rmSync(path, { force: true });
+                this.server = undefined;
+                this.adopt(socket);
+                resolve(socket);
+            });
+            server.listen(path, () => {
+                chmodSync(path, 0o600);
+                // Opened by the system, not started as a child: that is what makes it an app of its own to the privacy settings.
+                execFile("/usr/bin/open", ["-n", "-g", "-a", this.app, "--args", "--connect", path, ...(this.dryRun ? ["--dry-run"] : [])], (error) => {
+                    if (error)
+                        fail(new Error(`LinkShell.app could not be opened: ${error.message}`));
+                });
+            });
+            this.server = server;
+        });
+    }
+    adopt(socket) {
+        this.socket = socket;
+        socket.on("error", () => { });
+        socket.on("close", () => {
+            if (this.socket !== socket)
+                return;
+            this.socket = undefined;
+            this.status = undefined;
+            // The app went (quit, or crashed): each viewer hears it, and the next one to ask opens it again.
+            for (const route of this.routes.values())
+                route({ t: "gone" });
+            this.routes.clear();
+        });
+        createInterface({ input: socket }).on("line", (line) => {
+            const message = parse(line);
+            if (!message)
+                return;
+            if (message.t === "status") {
+                this.status = statusOf(message);
+                for (const waiter of this.waiting.splice(0))
+                    waiter(this.status);
+            }
+            else if (message.t === "trusted" && this.status) {
+                this.status = { ...this.status, trusted: message.on === true };
+                for (const watcher of this.watchers)
+                    watcher(this.status);
+            }
+            else if (typeof message.v === "string") {
+                this.routes.get(message.v)?.(message);
+            }
+        });
+    }
+    async write(message) {
+        const socket = await this.link();
+        socket.write(`${JSON.stringify(message)}\n`);
+    }
+    /** What the app may do. It says so as it connects; asked again, it looks again. */
+    async access() {
+        await this.link();
+        if (this.status) {
+            const answer = new Promise((resolve) => this.waiting.push(resolve));
+            await this.write({ t: "status" });
+            return answer;
+        }
+        return new Promise((resolve) => this.waiting.push(resolve));
+    }
+    /** The system's dialog and its settings page, for the app. */
+    ask(what = "control") {
+        return this.write({ t: what === "recording" ? "ask-recording" : "ask" });
+    }
+    /**
+     * Has the app run a screen capture: as the app's child, the recording is the
+     * app's to be allowed. The picture comes down a socket of its own; the
+     * returned function ends the capture.
+     */
+    async capture(exec, args, on) {
+        await this.link();
+        const id = `capture-${randomBytes(6).toString("hex")}`;
+        const path = join(tmpdir(), `linkshell-capture-${process.pid}-${randomBytes(4).toString("hex")}.sock`);
+        const server = createServer((socket) => {
+            server.close();
+            rmSync(path, { force: true });
+            socket.on("error", () => { });
+            socket.on("data", on.data);
+        });
+        let over = false;
+        this.routes.set(id, (message) => {
+            if (over || (message.t !== "captured" && message.t !== "gone"))
+                return;
+            over = true;
+            this.routes.delete(id);
+            server.close();
+            rmSync(path, { force: true });
+            on.exit(typeof message.code === "number" ? message.code : -1, typeof message.errors === "string" ? message.errors : "");
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(path, () => {
+                chmodSync(path, 0o600);
+                resolve();
+            });
+        });
+        await this.write({ t: "capture", v: id, exec, args, socket: path });
+        return () => {
+            if (!over && this.socket && !this.socket.destroyed)
+                this.socket.write(`${JSON.stringify({ t: "stop", v: id })}\n`);
+        };
+    }
+    async join(id, screen, route, watcher) {
+        this.routes.set(id, route);
+        this.watchers.add(watcher);
+        await this.write({ t: "open", v: id, screen });
+    }
+    send(id, event) {
+        if (this.socket && !this.socket.destroyed && this.routes.has(id))
+            this.socket.write(`${JSON.stringify({ ...event, v: id })}\n`);
+    }
+    leave(id, watcher) {
+        this.watchers.delete(watcher);
+        if (!this.routes.has(id))
+            return;
+        if (this.socket && !this.socket.destroyed)
+            this.socket.write(`${JSON.stringify({ t: "close", v: id })}\n`);
+        // What the app says as it lets go (a dry run's last report) still finds its viewer.
+        setTimeout(() => this.routes.delete(id), 1000).unref();
+    }
+    /** The host is going: the app leaves when its socket closes. */
+    close() {
+        this.server?.close();
+        this.socket?.destroy();
+    }
+}
+let shared;
+function helperApp(app, dryRun, log) {
+    shared ??= new HelperApp(app, dryRun, log);
+    return shared;
+}
+/** Ends the helper app, if this process opened one. */
+export function closeInputApp() {
+    shared?.close();
+    shared = undefined;
+}
+/** The signed app, opened when it isn't yet; undefined where the package has none. */
+export function inputApp(log) {
+    const app = shippedApp();
+    return app ? helperApp(app, dryRunByDefault(), log) : undefined;
+}
+// ── One viewer's control of one display ─────────────────────────────
 export class InputControl {
     listener;
     log;
     options;
     child;
+    joined;
     stopped = false;
-    constructor(listener, log, options = {}) {
+    started = false;
+    constructor(listener, log, 
+    /** `app: false` keeps to a child process even when the package has the app (tests). */
+    options = {}) {
         this.listener = listener;
         this.log = log;
         this.options = options;
     }
     /** Starts the helper for the display ffmpeg calls "Capture screen `screen`". Reports through the listener; never throws. */
     async start(screen) {
-        if (this.child || this.stopped)
+        if (this.started || this.stopped)
             return;
+        this.started = true;
         if (process.platform !== "darwin") {
             this.listener.state({ available: false, reason: "暂时只能控制 macOS 电脑" });
             return;
         }
+        const dryRun = this.options.dryRun ?? dryRunByDefault();
+        const app = this.options.app === false ? undefined : shippedApp();
+        if (app) {
+            try {
+                await this.joinApp(helperApp(app, dryRun, this.log), screen);
+                return;
+            }
+            catch (error) {
+                // The app's own program still works as a child of the host: the permission is then the terminal's.
+                this.log(`[screen] ${error.message}; controlling as the host's own process instead`);
+            }
+        }
         let path;
         try {
-            path = await inputHelper(this.log);
+            path = await childHelper(this.log, app);
         }
         catch (error) {
             this.listener.state({ available: false, reason: error.message });
             return;
         }
-        if (this.child || this.stopped)
+        if (this.stopped)
             return;
-        const dryRun = this.options.dryRun ?? process.env.LINKSHELL_INPUT_DRY_RUN === "1";
+        this.spawn(path, screen, dryRun);
+    }
+    async joinApp(app, screen) {
+        const id = randomBytes(6).toString("hex");
+        let named = "";
+        const watcher = (status) => this.listener.state({ available: true, trusted: status.trusted, app: named || status.app });
+        await app.join(id, screen, (message) => {
+            if (message.t === "ready") {
+                named = typeof message.app === "string" ? message.app : "";
+                this.listener.state({ available: true, trusted: message.trusted === true, app: named });
+            }
+            else if (message.t === "gone") {
+                this.joined = undefined;
+                this.started = false;
+                this.listener.state({ available: false, reason: "电脑上的 LinkShell 控制组件退出了，重新选择控制方式即可" });
+            }
+            else
+                this.heard(message);
+        }, watcher);
+        this.joined = { app, id, watcher };
+        if (this.stopped)
+            this.stop();
+    }
+    spawn(path, screen, dryRun) {
         const child = spawn(path, [String(screen), ...(dryRun ? ["--dry-run"] : [])], { stdio: ["pipe", "pipe", "ignore"] });
         this.child = child;
         child.on("error", (error) => {
@@ -119,36 +440,51 @@ export class InputControl {
         });
         // The viewer going away mid-write is not an error worth a crash.
         child.stdin.on("error", () => { });
+        let named = "";
         createInterface({ input: child.stdout }).on("line", (line) => {
-            let message;
-            try {
-                message = JSON.parse(line);
-            }
-            catch {
+            const message = parse(line);
+            if (!message)
                 return;
+            if (message.t === "ready") {
+                named = typeof message.app === "string" ? message.app : "";
+                this.listener.state({ available: true, trusted: message.trusted === true, app: named });
             }
-            if (message.t === "ready")
-                this.listener.state({ available: true, trusted: message.trusted === true });
             else if (message.t === "trusted")
-                this.listener.state({ available: true, trusted: message.v === true });
-            else if (message.t === "cursor" && typeof message.x === "number" && typeof message.y === "number")
-                this.listener.cursor(message.x, message.y);
-            else if (message.t === "posted")
-                this.listener.posted?.(message);
+                this.listener.state({ available: true, trusted: message.on === true, app: named });
+            else
+                this.heard(message);
         });
     }
+    heard(message) {
+        if (message.t === "cursor" && typeof message.x === "number" && typeof message.y === "number")
+            this.listener.cursor(message.x, message.y);
+        else if (message.t === "posted")
+            this.listener.posted?.(message);
+    }
     /** Passes on one event from the viewer; anything that is not one is dropped. */
     send(raw) {
-        const stdin = this.child?.stdin;
-        if (!stdin?.writable)
-            return;
         const parsed = inputEvent.safeParse(raw);
-        if (parsed.success)
+        if (!parsed.success)
+            return;
+        if (this.joined) {
+            // Asking opens the settings too, which the app does for itself.
+            if (parsed.data.t === "prompt")
+                void this.joined.app.ask().catch(() => { });
+            else
+                this.joined.app.send(this.joined.id, parsed.data);
+            return;
+        }
+        const stdin = this.child?.stdin;
+        if (stdin?.writable)
             stdin.write(`${JSON.stringify(parsed.data)}\n`);
     }
-    /** Ends the helper; on its way out it lets go of any button still held. */
+    /** Ends this viewer's control; on its way out the helper lets go of any button still held. */
     stop() {
         this.stopped = true;
+        if (this.joined) {
+            this.joined.app.leave(this.joined.id, this.joined.watcher);
+            this.joined = undefined;
+        }
         this.child?.stdin?.end();
         const child = this.child;
         if (child)