@parlor/agent-host 0.0.0-stage → 0.2.0

package/dist/daemon.d.ts

@@ -0,0 +1,50 @@
+import type { AgentLauncher } from "./acp.js";
+import { type GrantStore, type HostKeys } from "./grants.js";
+import type { McpProxy } from "./mcp-proxy.js";
+import type { HostPaths } from "./paths.js";
+import { type RemotePolicy } from "./policy.js";
+import type { SessionPool } from "./pool.js";
+import { type LocalPrompter } from "./prompter.js";
+import { type HostRelease } from "./service.js";
+import type { TrustStore } from "./trust.js";
+export interface DaemonDeps {
+    readonly release: HostRelease;
+    readonly paths: HostPaths;
+    readonly grants: GrantStore;
+    readonly keys: HostKeys;
+    readonly trust: TrustStore;
+    readonly pool: SessionPool;
+    readonly proxy: McpProxy;
+    readonly launcher: AgentLauncher;
+    readonly prompter: LocalPrompter;
+    readonly policy: RemotePolicy;
+    /** The `service.lock` token of the `ensureService` that spawned this daemon, which holds the lock for it. */
+    readonly lockToken?: string | undefined;
+}
+/**
+ * One per user per computer, for every app: an `AppLink` per grant, the session pool,
+ * the proxy socket and the control socket. Started only through `ensureService`.
+ */
+export interface HostDaemon {
+    start(): Promise<void>;
+    connect(appOrigin: string): Promise<void>;
+    disconnect(appOrigin: string): Promise<void>;
+    /** Hands links over to a newer release; running turns finish here first. */
+    handover(): Promise<void>;
+    stop(): Promise<void>;
+}
+/**
+ * Agents start `parlor-host mcp-proxy` by name. An entry named otherwise, such as the
+ * published `dist/main.js` that `parlor dev` runs with node, gets a shim instead of a link.
+ */
+export declare function putHostCommandFirstOnPath(root: string, entry?: string | undefined): Promise<void>;
+/** The daemon a service runs: once it handed over, `drained` settles after its last turn. */
+export interface ServiceDaemon extends HostDaemon {
+    readonly drained: Promise<void>;
+}
+export declare class HostAlreadyRunning extends Error {
+    readonly name = "HostAlreadyRunning";
+    constructor();
+}
+export declare function createHostDaemon(deps: DaemonDeps): ServiceDaemon;
+//# sourceMappingURL=daemon.d.ts.map

package/dist/daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAI9C,OAAO,EAA8B,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAKzF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAQ/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAyC,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,eAAe,CAAC;AAI9D,OAAO,EAAE,KAAK,WAAW,EAAoC,MAAM,cAAc,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,6GAA6G;IAC7G,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,4EAA4E;IAC5E,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAeD;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAAM,GAAG,SAAuB,GACtC,OAAO,CAAC,IAAI,CAAC,CAqBf;AAWD,6FAA6F;AAC7F,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,SAAkB,IAAI,wBAAwB;IAC9C,cAEC;CACF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,CA4fhE"}

package/dist/daemon.js

@@ -0,0 +1,543 @@
+import { chmod, mkdir, readlink, realpath, rm, symlink, writeFile, } from "node:fs/promises";
+import { createServer } from "node:net";
+import { basename, delimiter, dirname, join } from "node:path";
+import { HOST_PROTOCOL, } from "@parlor/chat";
+import { ActionError, asId, DEV_USER_ID } from "@parlor/core";
+import { detectAgents, loadProfiles } from "./agents.js";
+import { connectControl } from "./control.js";
+import { requestDevHostToken } from "./dev-host.js";
+import { devHostKeys } from "./grants.js";
+import { onLines } from "./lines.js";
+import { createAppLink } from "./link.js";
+import { withInheritedLock } from "./lock.js";
+import { logEvent, openHostLog } from "./log.js";
+import { computerName, platformName, workspaceOf } from "./naming.js";
+import { pairingDeviceOf, startLocalPairing, UnrevokedGrant, } from "./pairing.js";
+import { DEV_POLICY, loadPolicy, presenceDueAt } from "./policy.js";
+import { printable } from "./prompter.js";
+import { compareVersions, RELEASE_KEY, signedRelease } from "./release.js";
+import { revokeGrant } from "./revoke.js";
+import { selfEntry } from "./self.js";
+import { installLoginItem, installRelease } from "./service.js";
+import { runTurn } from "./turn.js";
+const CONNECT_TIMEOUT_MS = 15_000;
+const OFFLINE_REPORT_MS = 1_000;
+function incompatibleMessage(grant, welcome) {
+    return welcome.reason === "host_too_old"
+        ? `Update Parlor Host to use ${grant.appName}: it speaks host protocol ${HOST_PROTOCOL}, and ${grant.appName} needs ${welcome.protocols.min}.`
+        : `${grant.appName} is older than this Parlor Host: it speaks host protocol ${welcome.protocols.max}, and this computer needs ${HOST_PROTOCOL}.`;
+}
+const shellQuote = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
+/**
+ * Agents start `parlor-host mcp-proxy` by name. An entry named otherwise, such as the
+ * published `dist/main.js` that `parlor dev` runs with node, gets a shim instead of a link.
+ */
+export async function putHostCommandFirstOnPath(root, entry = selfEntry()) {
+    if (!entry)
+        return;
+    const bin = join(root, "bin");
+    const link = join(bin, "parlor-host");
+    await mkdir(bin, { recursive: true, mode: 0o700 });
+    const target = await realpath(entry);
+    if (basename(entry).startsWith("parlor-host")) {
+        if ((await readlink(link).catch(() => undefined)) !== target) {
+            await rm(link, { force: true });
+            await symlink(target, link);
+        }
+    }
+    else {
+        await rm(link, { force: true });
+        await writeFile(link, `#!/bin/sh\nexec ${shellQuote(process.execPath)} ${shellQuote(target)} "$@"\n`, { mode: 0o700 });
+    }
+    const path = (process.env.PATH ?? "").split(delimiter).filter((dir) => dir !== bin);
+    process.env.PATH = [bin, ...path].join(delimiter);
+}
+export class HostAlreadyRunning extends Error {
+    name = "HostAlreadyRunning";
+    constructor() {
+        super("Parlor Host is already running on this computer.");
+    }
+}
+export function createHostDaemon(deps) {
+    const { paths } = deps;
+    const links = new Map();
+    const devTokens = new Map();
+    const name = computerName();
+    const platform = platformName();
+    let profiles = [];
+    let agents = [];
+    let control;
+    let startup = Promise.resolve();
+    const clients = new Set();
+    const claim = async (link) => {
+        try {
+            return await link.api.calls.call("hostClaim", {});
+        }
+        catch (error) {
+            if (!(error instanceof ActionError && error.code === "not_found")) {
+                logEvent("claim_failed", {
+                    appOrigin: link.grant.appOrigin,
+                    error: String(error),
+                });
+            }
+            return undefined;
+        }
+    };
+    const running = new Set();
+    let handedOver = false;
+    let finishing = false;
+    let finishHandover = () => undefined;
+    const drained = new Promise((resolve) => (finishHandover = resolve));
+    const run = (state, claimed) => {
+        const { link } = state;
+        logEvent("turn_claimed", { appOrigin: link.grant.appOrigin, turnId: claimed.turnId });
+        state.turns += 1;
+        const turn = (link.grant.dev ? Promise.resolve(DEV_POLICY) : loadPolicy(paths.policy, deps.policy))
+            .then((policy) => runTurn(claimed, {
+            link,
+            profiles,
+            launcher: deps.launcher,
+            pool: deps.pool,
+            proxy: deps.proxy,
+            trust: {
+                ...deps.trust,
+                pin: async (appOrigin, device) => {
+                    await deps.trust.pin(appOrigin, device);
+                    void report(state).catch(() => undefined);
+                },
+                forget: async (appOrigin, deviceId) => {
+                    await deps.trust.forget(appOrigin, deviceId);
+                    void report(state).catch(() => undefined);
+                },
+            },
+            policy,
+            prompter: deps.prompter,
+            now: Date.now,
+            pairing: {
+                secret: async () => (await deps.grants.get(link.grant.appOrigin))?.pairingSecret,
+                forget: async () => {
+                    const saved = await deps.grants.get(link.grant.appOrigin);
+                    if (!saved?.pairingSecret)
+                        return;
+                    const { pairingSecret: _used, ...rest } = saved;
+                    await deps.grants.save(rest);
+                },
+            },
+        }))
+            .then((outcome) => logEvent("turn_finished", { turnId: claimed.turnId, outcome }), (error) => logEvent("turn_finished", { turnId: claimed.turnId, error: String(error) }))
+            .finally(() => {
+            state.turns -= 1;
+            running.delete(turn);
+            settleHandover();
+        });
+        running.add(turn);
+    };
+    const claimLoop = async (state) => {
+        do {
+            state.again = false;
+            for (let claimed = await claim(state.link); claimed; claimed = state.link.mode === "serving" ? await claim(state.link) : undefined) {
+                run(state, claimed);
+            }
+        } while (state.again && state.link.mode === "serving");
+    };
+    const wake = (state) => {
+        if (state.link.mode !== "serving")
+            return;
+        if (state.claiming) {
+            state.again = true;
+            return;
+        }
+        state.claiming = claimLoop(state).finally(() => {
+            state.claiming = undefined;
+        });
+    };
+    const closeLink = async (origin, reason) => {
+        const state = links.get(origin);
+        links.delete(origin);
+        await state?.link.stop();
+        await deps.pool.drop(origin);
+        if (state)
+            logEvent("link_closed", { appOrigin: origin, reason });
+    };
+    const forget = async (grant) => {
+        devTokens.delete(grant.appOrigin);
+        await deps.grants.remove(grant.appOrigin);
+        await deps.keys.remove(grant.appOrigin);
+        await deps.trust.forget(grant.appOrigin);
+        await deps.pool.forget(grant);
+    };
+    const open = (grant, keys) => {
+        const origin = grant.appOrigin;
+        let state;
+        const link = createAppLink(grant, {
+            keys,
+            hostVersion: deps.release.version,
+            hostName: name,
+            platform,
+            fetch: (input, init) => fetch(input, init),
+            onWake: () => wake(state),
+            busy: () => state.turns > 0,
+            onRevoked: () => {
+                if (links.get(origin) !== state)
+                    return;
+                if (grant.dev)
+                    void reattach(grant);
+                else
+                    void closeLink(origin, "revoked").then(() => forget(grant));
+            },
+            onIncompatible: (refused, welcome) => {
+                state.incompatible = incompatibleMessage(refused, welcome);
+                process.stderr.write(`${printable(state.incompatible)}\n`);
+            },
+        });
+        state = {
+            link,
+            keys,
+            claiming: undefined,
+            again: false,
+            incompatible: undefined,
+            turns: 0,
+        };
+        links.set(origin, state);
+        link.start();
+        return state;
+    };
+    const pinnedDevices = async (state) => {
+        if (state.link.grant.dev)
+            return {};
+        const [pinned, policy] = await Promise.all([
+            deps.trust.list(state.link.grant.appOrigin),
+            loadPolicy(paths.policy, deps.policy),
+        ]);
+        const presenceDue = {};
+        for (const device of pinned) {
+            const due = presenceDueAt(policy, device);
+            if (due !== undefined)
+                presenceDue[device.deviceId] = due;
+        }
+        return { devices: pinned.map((device) => device.deviceId), presenceDue };
+    };
+    const report = async (state) => {
+        const reported = state.link.api.calls.call("hostReport", {
+            online: true,
+            agents,
+            ...(await pinnedDevices(state)),
+        });
+        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("The app did not answer in time.")), CONNECT_TIMEOUT_MS));
+        try {
+            await Promise.race([reported, timeout]);
+        }
+        catch (error) {
+            throw new Error(state.incompatible ?? (error instanceof Error ? error.message : String(error)), { cause: error });
+        }
+    };
+    const devGrant = async (origin) => {
+        const manifest = await fetch(`${origin}/_parlor/manifest`)
+            .then((response) => response.json())
+            .catch(() => undefined);
+        return {
+            appOrigin: origin,
+            appName: manifest?.app?.name ?? new URL(origin).host,
+            grantId: asId("grant", "dev"),
+            hostId: asId("host", "dev"),
+            account: { userId: DEV_USER_ID, name: "Developer" },
+            workspace: workspaceOf(paths.workspaces, origin),
+            createdAt: Date.now(),
+            dev: true,
+        };
+    };
+    const attach = async (origin, hostToken) => {
+        await closeLink(origin, "replaced");
+        devTokens.set(origin, hostToken);
+        await report(open(await devGrant(origin), devHostKeys(hostToken)));
+    };
+    const reattach = async (grant) => {
+        await closeLink(grant.appOrigin, "dev_server_restarted");
+        if (!devTokens.has(grant.appOrigin))
+            return;
+        try {
+            const token = await requestDevHostToken(grant.appOrigin);
+            if (devTokens.has(grant.appOrigin))
+                await attach(grant.appOrigin, token);
+        }
+        catch (error) {
+            logEvent("dev_attach_failed", { appOrigin: grant.appOrigin, error: String(error) });
+        }
+    };
+    const status = () => ({
+        state: "running",
+        version: deps.release.version,
+        apps: [...links.keys()],
+    });
+    const grantsOf = () => [...links.values()].map(({ link: { grant } }) => ({
+        appOrigin: grant.appOrigin,
+        appName: grant.appName,
+        grantId: grant.grantId,
+    }));
+    const daemon = {
+        drained,
+        async start() {
+            let finishStartup;
+            let failStartup;
+            startup = new Promise((resolve, reject) => {
+                finishStartup = resolve;
+                failStartup = reject;
+            });
+            startup.catch(() => undefined);
+            try {
+                await mkdir(paths.root, { recursive: true, mode: 0o700 });
+                await withInheritedLock(paths.lock, deps.lockToken, async () => {
+                    const answering = await connectControl(paths.control);
+                    if (answering) {
+                        answering.close();
+                        throw new HostAlreadyRunning();
+                    }
+                    await mkdir(dirname(paths.control), { recursive: true, mode: 0o700 });
+                    control = createServer(serve);
+                    await rm(paths.control, { force: true });
+                    await new Promise((resolve, reject) => {
+                        control.once("error", reject);
+                        control.listen(paths.control, () => resolve());
+                    });
+                    await chmod(paths.control, 0o600);
+                });
+                openHostLog(join(paths.root, "logs", "daemon.log"));
+                await putHostCommandFirstOnPath(paths.root);
+                await deps.proxy.listen(paths.proxy);
+                profiles = await loadProfiles(paths.agents);
+                agents = await detectAgents(profiles);
+                finishStartup();
+            }
+            catch (error) {
+                failStartup(error);
+                throw error;
+            }
+            logEvent("daemon_started", {
+                version: deps.release.version,
+                agents: agents.map((a) => a.id),
+            });
+            for (const grant of await deps.grants.list()) {
+                if (grant.declined)
+                    continue;
+                void report(open(grant, deps.keys)).catch((error) => logEvent("link_failed", { appOrigin: grant.appOrigin, error: String(error) }));
+            }
+        },
+        async connect(appOrigin) {
+            const grant = await deps.grants.get(appOrigin);
+            if (!grant || grant.declined) {
+                throw new Error(`This computer is not connected to ${appOrigin}.`);
+            }
+            const current = links.get(appOrigin);
+            if (current?.link.grant.grantId === grant.grantId) {
+                await report(current);
+                return;
+            }
+            await closeLink(appOrigin, "replaced");
+            if (current)
+                await deps.pool.forget(current.link.grant);
+            await report(open(grant, deps.keys));
+        },
+        async disconnect(appOrigin) {
+            const state = links.get(appOrigin);
+            const grant = state?.link.grant ?? (await deps.grants.get(appOrigin));
+            if (!grant)
+                throw new Error(`This computer is not connected to ${appOrigin}.`);
+            if (state) {
+                await state.link.stop({ revoke: true });
+            }
+            else {
+                await revokeGrant({
+                    appOrigin,
+                    appName: grant.appName,
+                    assert: (request) => deps.keys.assert(appOrigin, request),
+                });
+            }
+            await closeLink(appOrigin, "disconnected");
+            await forget(grant);
+        },
+        async handover() {
+            if (handedOver)
+                return;
+            handedOver = true;
+            for (const state of links.values())
+                state.link.drain();
+            await Promise.all([...links.values()].map((state) => state.claiming));
+            const closing = control;
+            control = undefined;
+            closing?.close();
+            await Promise.all([rm(paths.control, { force: true }), deps.proxy.stopListening()]);
+            logEvent("handover_started", { version: deps.release.version });
+        },
+        async stop() {
+            if (!handedOver) {
+                await Promise.all([...links.values()].map((state) => Promise.race([
+                    state.link.api.calls.call("hostReport", { online: false, agents }),
+                    new Promise((resolve) => setTimeout(resolve, OFFLINE_REPORT_MS)),
+                ]).catch(() => undefined)));
+            }
+            for (const origin of [...links.keys()])
+                await closeLink(origin, "stopped");
+            for (const socket of clients)
+                socket.destroy();
+            const closing = control;
+            control = undefined;
+            if (closing)
+                await new Promise((resolve) => closing.close(() => resolve()));
+            if (!handedOver)
+                await rm(paths.control, { force: true });
+            await deps.proxy.close();
+        },
+    };
+    const settleHandover = () => {
+        if (!handedOver || running.size > 0 || finishing)
+            return;
+        finishing = true;
+        void (async () => {
+            for (const origin of [...links.keys()])
+                await closeLink(origin, "handed_over");
+            await Promise.all([...clients].map((socket) => new Promise((resolve) => {
+                socket.end(() => resolve());
+                setTimeout(resolve, OFFLINE_REPORT_MS).unref();
+            })));
+            logEvent("handover_finished", { version: deps.release.version });
+            finishHandover();
+        })();
+    };
+    const handOverTo = async (binary, signature) => {
+        const release = await signedRelease(binary, signature, RELEASE_KEY);
+        if (!release)
+            return { ok: false, error: "unsigned" };
+        if (compareVersions(release.version, deps.release.version) <= 0) {
+            return { ok: false, error: "downgrade" };
+        }
+        if (!(await installRelease(paths, { binary, signature }, release))) {
+            return { ok: false, error: "unsigned" };
+        }
+        await installLoginItem(paths);
+        await daemon.handover();
+        setImmediate(settleHandover);
+        return { ok: true };
+    };
+    const pairings = new Map();
+    const pendingPairing = (appOrigin) => {
+        const origin = new URL(appOrigin).origin;
+        return { origin, pairing: pairings.get(origin) };
+    };
+    const confirmPairing = async (request) => {
+        const { origin, pairing } = pendingPairing(request.appOrigin);
+        if (!pairing)
+            return { ok: false, error: "No pairing was started for this app." };
+        pairings.delete(origin);
+        let outcome;
+        try {
+            outcome = await pairing.confirm(request.connect);
+        }
+        catch (error) {
+            if (!(error instanceof UnrevokedGrant))
+                throw error;
+            await deps.grants.save(error.grant);
+            return { ok: false, error: "declined_locally" };
+        }
+        if (!outcome.paired)
+            return { ok: false, error: outcome.reason };
+        const { grant } = outcome;
+        await deps.grants.save(grant);
+        const device = pairingDeviceOf(request.device);
+        if (device) {
+            await deps.trust.pin(grant.appOrigin, {
+                deviceId: asId("device", device.deviceId),
+                signingKey: device.signingKey,
+                presenceKey: device.presenceKey,
+                name: device.name,
+                platform: device.platform,
+                approvedAt: Date.now(),
+                via: "pairing",
+            });
+        }
+        await daemon.connect(grant.appOrigin);
+        return { ok: true };
+    };
+    const handle = async (request) => {
+        if (request.op !== "hello")
+            await startup;
+        switch (request.op) {
+            case "hello":
+                return { ok: true, release: deps.release };
+            case "handover":
+                return handOverTo(request.binary, request.signature);
+            case "status":
+                return { ok: true, status: status(), grants: grantsOf() };
+            case "begin_local_pairing": {
+                const { origin } = pendingPairing(request.appOrigin);
+                const existing = await deps.grants.get(origin);
+                if (existing && !existing.declined) {
+                    return {
+                        ok: false,
+                        error: `This computer is already connected to ${existing.appName}.`,
+                    };
+                }
+                const pairing = startLocalPairing({
+                    appOrigin: origin,
+                    hostName: name,
+                    platform,
+                    keys: deps.keys,
+                    workspaceRoot: paths.workspaces,
+                });
+                pairings.set(origin, pairing);
+                const begun = await pairing.pairing;
+                logEvent("local_pairing_begun", {
+                    appOrigin: origin,
+                    matchingCode: begun.matchingCode,
+                });
+                return { ok: true, pairing: begun };
+            }
+            case "finish_local_pairing": {
+                const { pairing } = pendingPairing(request.appOrigin);
+                if (!pairing)
+                    return { ok: false, error: "No pairing was started for this app." };
+                return { ok: true, ...(await pairing.finish(request.code)) };
+            }
+            case "confirm_local_pairing":
+                return confirmPairing(request);
+            case "connect":
+                await daemon.connect(request.appOrigin);
+                return { ok: true };
+            case "disconnect":
+                await daemon.disconnect(request.appOrigin);
+                return { ok: true };
+            case "dev_attach":
+                await attach(request.appOrigin, request.hostToken);
+                return { ok: true };
+            case "dev_detach":
+                devTokens.delete(request.appOrigin);
+                await closeLink(request.appOrigin, "detached");
+                return { ok: true };
+        }
+    };
+    function serve(socket) {
+        clients.add(socket);
+        socket.on("close", () => clients.delete(socket));
+        socket.on("error", () => socket.destroy());
+        onLines(socket, (line) => {
+            let request;
+            try {
+                request = JSON.parse(line);
+            }
+            catch {
+                socket.write(`${JSON.stringify({ ok: false, error: "Not JSON." })}\n`);
+                return;
+            }
+            void handle(request)
+                .catch((error) => ({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            }))
+                .then((reply) => {
+                if (!socket.destroyed)
+                    socket.write(`${JSON.stringify(reply ?? { ok: false, error: "Unknown op." })}\n`);
+            });
+        });
+    }
+    return daemon;
+}
+//# sourceMappingURL=daemon.js.map