gestalt-mobile 0.1.0

package/dist/server/server/features/sessions/promote-recent-thread/endpoint.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+const requestSchema = z.object({
+    threadId: z.string().min(1),
+    cwd: z.string().startsWith('/'),
+});
+export function registerPromoteRecentThread(app, deps) {
+    app.post('/api/sessions/recent-threads/open', async (request, reply) => {
+        const parsed = requestSchema.safeParse(request.body);
+        if (!parsed.success)
+            return reply.code(400).send({ code: 'INVALID_RECENT_THREAD' });
+        const thread = (await deps.list()).find((candidate) => candidate.id === parsed.data.threadId && candidate.cwd === parsed.data.cwd);
+        if (!thread)
+            return reply.code(404).send({ code: 'RECENT_THREAD_NOT_FOUND' });
+        try {
+            return reply.code(202).send(await deps.promote(thread));
+        }
+        catch (error) {
+            return reply.code(409).send({
+                code: 'RECENT_THREAD_OPEN_FAILED',
+                detail: error instanceof Error ? error.message : 'Could not open the recent session.',
+            });
+        }
+    });
+}

package/dist/server/server/features/sessions/promote-recent-thread/use-case.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { RelaySession } from '../model/relay-session.js';
+export async function promoteRecentThread(thread, deps) {
+    const existing = deps.list().find((session) => session.threadId === thread.id);
+    if (existing?.state === 'ready' || existing?.state === 'turnActive')
+        return existing;
+    const now = deps.now();
+    const imported = existing ??
+        RelaySession.fromExistingThread({
+            id: deps.createId(),
+            workspaceId: thread.cwd,
+            workspacePath: thread.cwd,
+            profile: 'default',
+            threadId: thread.id,
+            now,
+        }).snapshot;
+    if (!existing)
+        deps.save(imported);
+    const active = await deps.restore(imported);
+    deps.save(active);
+    return active;
+}

package/dist/server/server/features/sessions/release-session/endpoint.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { idempotencyKey } from '../../../platform/http/idempotency.js';
+export function registerReleaseSession(app, deps) {
+    app.post('/api/sessions/:id/release', async (request, reply) => {
+        const id = request.params.id;
+        const key = idempotencyKey(request.headers);
+        const scope = `release-session:${id}`;
+        const prior = key ? deps.idempotency?.get(scope, key) : null;
+        if (prior)
+            return reply.code(prior.statusCode).send(JSON.parse(prior.body));
+        const session = deps.find(id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const released = deps.release(session);
+        deps.save(released);
+        deps.close(id);
+        if (key)
+            deps.idempotency?.put(scope, key, 202, JSON.stringify(released));
+        return reply.code(202).send(released);
+    });
+}

package/dist/server/server/features/sessions/release-session/use-case.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { RelaySession } from '../model/relay-session.js';
+export function release(session, now) {
+    return RelaySession.rehydrate(session).release(now).snapshot;
+}

package/dist/server/server/features/sessions/respond-interaction/endpoint.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerRespondInteraction(app, deps) {
+    app.post('/api/sessions/:id/interactions/:requestId', async (request, reply) => {
+        const { id, requestId } = request.params;
+        if (!deps.exists(id))
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const value = request.body;
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return reply.code(400).send({ code: 'INTERACTION_RESPONSE_INVALID' });
+        if (deps.validate && !deps.validate(id, requestId, value))
+            return reply.code(400).send({ code: 'INTERACTION_RESPONSE_INVALID' });
+        if (!deps.reply(id, requestId, value))
+            return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
+        const resolvedAt = deps.now();
+        if (!deps.resolve(id, requestId, resolvedAt))
+            return reply.code(409).send({ code: 'INTERACTION_NOT_PENDING' });
+        deps.resolved?.(id, requestId, resolvedAt);
+        return reply.code(202).send({ accepted: true });
+    });
+}

package/dist/server/server/features/sessions/restore-session/endpoint.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { idempotencyKey } from '../../../platform/http/idempotency.js';
+import { canRestore } from './use-case.js';
+export function registerRestoreSession(app, deps) {
+    app.post('/api/sessions/:id/restore', async (request, reply) => {
+        const id = request.params.id;
+        const key = idempotencyKey(request.headers);
+        const scope = `restore-session:${id}`;
+        const prior = key ? deps.idempotency?.get(scope, key) : null;
+        if (prior)
+            return reply.code(prior.statusCode).send(JSON.parse(prior.body));
+        const session = deps.find(id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        if (!canRestore(session))
+            return reply.code(409).send({ code: 'SESSION_CANNOT_RESTORE' });
+        const restored = await deps.restore(session);
+        deps.save(restored);
+        if (key)
+            deps.idempotency?.put(scope, key, 200, JSON.stringify(restored));
+        return reply.send(restored);
+    });
+}

package/dist/server/server/features/sessions/restore-session/use-case.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { RelaySession } from '../model/relay-session.js';
+export function canRestore(session) {
+    return (session.threadId !== null &&
+        (session.state === 'stopped' ||
+            session.state === 'released' ||
+            session.state === 'attentionRequired'));
+}
+export function restore(session, now) {
+    if (!canRestore(session))
+        throw new Error('SESSION_CANNOT_RESTORE');
+    return RelaySession.rehydrate(session).beginRecovery(now).restore(now).snapshot;
+}

package/dist/server/server/features/sessions/session-events/endpoint.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { WebSocketServer } from 'ws';
+import { replayOrResync } from '../../../platform/events/replay.js';
+import { isSlowClient } from '../../../platform/events/slow-client.js';
+import { installWebSocketHeartbeat } from '../../../platform/events/websocket-heartbeat.js';
+export function registerSessionEvents(app, deps) {
+    const server = new WebSocketServer({ noServer: true });
+    app.server.on('upgrade', (request, socket, head) => {
+        const url = new URL(request.url ?? '/', 'http://relay.invalid');
+        const match = /^\/api\/sessions\/([^/]+)\/events$/.exec(url.pathname);
+        const after = Number(url.searchParams.get('after') ?? '0');
+        if (!match || !Number.isSafeInteger(after) || after < 0 || !deps.exists(match[1])) {
+            socket.destroy();
+            return;
+        }
+        server.handleUpgrade(request, socket, head, (connection) => {
+            const sessionId = match[1];
+            const send = (event) => {
+                if (isSlowClient(connection.bufferedAmount))
+                    return connection.close(1013, 'slow client');
+                connection.send(JSON.stringify({ type: 'relay.event', event }));
+            };
+            const replay = replayOrResync(deps.since(sessionId, after), after);
+            if (replay.kind === 'resync') {
+                const currentSequence = deps.since(sessionId, 0).at(-1)?.sequence ?? after;
+                connection.send(JSON.stringify({ type: 'relay.resyncRequired', currentSequence }));
+                connection.close();
+                return;
+            }
+            replay.events.forEach(send);
+            const unsubscribe = deps.subscribe(sessionId, send);
+            const removeHeartbeat = installWebSocketHeartbeat(connection);
+            connection.on('close', () => {
+                removeHeartbeat();
+                unsubscribe();
+            });
+        });
+    });
+    app.addHook('onClose', async () => server.close());
+}

package/dist/server/server/features/sessions/start-session/endpoint.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { idempotencyKey } from '../../../platform/http/idempotency.js';
+import { parseStartSessionRequest } from './request.js';
+import { startSession } from './use-case.js';
+export function registerStartSession(app, deps) {
+    app.post('/api/sessions', async (request, reply) => {
+        const key = idempotencyKey(request.headers);
+        const prior = key ? deps.idempotency?.get('start-session', key) : null;
+        if (prior)
+            return reply.code(prior.statusCode).send(JSON.parse(prior.body));
+        const body = parseStartSessionRequest(request.body);
+        if (!body)
+            return reply.code(400).type('application/problem+json').send({
+                type: 'urn:gestalt-mobile:error:invalid-start-session-request',
+                title: 'Invalid start session request',
+                status: 400,
+                detail: 'Workspace, profile, and Codex session settings must be valid.',
+                code: 'INVALID_START_SESSION_REQUEST',
+                retryable: false,
+            });
+        let started;
+        try {
+            started = await startSession(body, deps);
+        }
+        catch (error) {
+            deps.reportFailure?.('start-session', error);
+            throw error;
+        }
+        if (key)
+            deps.idempotency?.put('start-session', key, 202, JSON.stringify(started));
+        return reply.code(202).send(started);
+    });
+}

package/dist/server/server/features/sessions/start-session/request.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+const schema = z.object({
+    workspaceId: z.string().min(1),
+    profile: z.string().min(1),
+    model: z
+        .string()
+        .trim()
+        .optional()
+        .transform((value) => value || undefined),
+    sandbox: z.enum(['read-only', 'workspace-write', 'danger-full-access']).optional(),
+    approvalPolicy: z.enum(['untrusted', 'on-request', 'never']).optional(),
+});
+/** Parses only settings that are safe to send directly to Codex thread/start. */
+export function parseStartSessionRequest(input) {
+    const result = schema.safeParse(input);
+    return result.success ? result.data : null;
+}

package/dist/server/server/features/sessions/start-session/use-case.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { RelaySession } from '../model/relay-session.js';
+export async function startSession(input, deps) {
+    const [workspace] = await Promise.all([
+        deps.workspaces.resolve(input.workspaceId),
+        deps.profiles.require(input.profile),
+    ]);
+    const session = RelaySession.create({
+        id: deps.createId(),
+        workspaceId: workspace.id,
+        workspacePath: workspace.realPath,
+        profile: input.profile,
+        now: deps.now(),
+    }).snapshot;
+    deps.save(session);
+    if (!deps.activate)
+        return session;
+    const active = await deps.activate(session, {
+        model: input.model,
+        sandbox: input.sandbox,
+        approvalPolicy: input.approvalPolicy,
+    });
+    deps.save(active);
+    return active;
+}

package/dist/server/server/features/sessions/start-turn/endpoint.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerStartTurn(app, deps) {
+    app.post('/api/sessions/:id/turns', async (request, reply) => {
+        const session = deps.find(request.params.id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const text = request.body.text?.trim() ?? '';
+        if (text.length > 100_000)
+            return reply.code(400).send({ code: 'TURN_INPUT_TOO_LONG' });
+        if (!text || session.state !== 'ready')
+            return reply.code(409).send({ code: 'SESSION_NOT_READY' });
+        const started = await deps.start(session, text);
+        deps.save(started);
+        return reply.code(202).send(started);
+    });
+}

package/dist/server/server/features/sessions/stop-session/endpoint.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { idempotencyKey } from '../../../platform/http/idempotency.js';
+export function registerStopSession(app, deps) {
+    app.post('/api/sessions/:id/stop', async (request, reply) => {
+        const id = request.params.id;
+        const key = idempotencyKey(request.headers);
+        const scope = `stop-session:${id}`;
+        const prior = key ? deps.idempotency?.get(scope, key) : null;
+        if (prior)
+            return reply.code(prior.statusCode).send(JSON.parse(prior.body));
+        const session = deps.find(id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const stopped = deps.stop(session);
+        deps.save(stopped);
+        deps.close(id);
+        if (key)
+            deps.idempotency?.put(scope, key, 202, JSON.stringify(stopped));
+        return reply.code(202).send(stopped);
+    });
+}

package/dist/server/server/features/sessions/stop-session/use-case.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { RelaySession } from '../model/relay-session.js';
+export function stop(session, now) {
+    return RelaySession.rehydrate(session).stop(now).snapshot;
+}

package/dist/server/server/features/sessions/turn/start-policy.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function mayStartTurn(state, text) {
+    return state === 'ready' && text.trim().length > 0;
+}

package/dist/server/server/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/** Server compilation marker; the application composition root is added by the health slice. */
+export {};

package/dist/server/server/main.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { runCli } from './cli.js';
+try {
+    process.exitCode = await runCli();
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : 'Gestalt Mobile startup failed');
+    process.exitCode = 1;
+}

package/dist/server/server/platform/catalog/codex-profile-catalog.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+const execute = promisify(execFile);
+const statusSchema = z.object({
+    profiles: z.array(z.object({
+        name: z.string(),
+        state: z.enum(['ok', 'not_logged_in', 'error']),
+        status: z.string(),
+        home: z.string().optional(),
+    })),
+});
+export class CodexProfileCatalog {
+    command;
+    defaultHomeExists;
+    constructor(command = async () => (await execute('codex-profile', ['status', '--json'])).stdout, defaultHomeExists = () => existsSync(join(homedir(), '.codex'))) {
+        this.command = command;
+        this.defaultHomeExists = defaultHomeExists;
+    }
+    async list() {
+        const profiles = statusSchema
+            .parse(JSON.parse(await this.command()))
+            .profiles.map(({ name, state, status }) => ({ name, state, status }));
+        return profiles.length || !this.defaultHomeExists()
+            ? profiles
+            : [{ name: 'default', state: 'ok', status: 'Using ~/.codex' }];
+    }
+    async require(name) {
+        const profile = (await this.list()).find((item) => item.name === name);
+        if (!profile)
+            throw new Error('PROFILE_NOT_FOUND');
+        return profile;
+    }
+}

package/dist/server/server/platform/catalog/filesystem-workspace-catalog.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createHash } from 'node:crypto';
+import { readdir, realpath, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+export class FilesystemWorkspaceCatalog {
+    root;
+    constructor(root) {
+        this.root = realpath(root);
+    }
+    async list() {
+        return (await this.entries()).map(({ id, name, git }) => ({ id, name, isGitRepository: git }));
+    }
+    async resolve(id) {
+        const found = (await this.entries()).find((entry) => entry.id === id);
+        if (!found)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        return { id: found.id, name: found.name, realPath: found.path };
+    }
+    async entries() {
+        const root = await this.root;
+        const children = await readdir(root, { withFileTypes: true });
+        const rootEntry = {
+            id: createHash('sha256').update(root).digest('base64url'),
+            name: '/',
+            path: root,
+            git: await stat(join(root, '.git'))
+                .then(() => true)
+                .catch(() => false),
+        };
+        const output = await Promise.all(children.map(async (child) => {
+            if (!child.isDirectory() && !child.isSymbolicLink())
+                return null;
+            try {
+                const path = await realpath(join(root, child.name));
+                const info = await stat(path);
+                if (!info.isDirectory() || relative(root, path).startsWith('..'))
+                    return null;
+                const git = await stat(join(path, '.git'))
+                    .then(() => true)
+                    .catch(() => false);
+                return {
+                    id: createHash('sha256').update(path).digest('base64url'),
+                    name: child.name,
+                    path,
+                    git,
+                };
+            }
+            catch {
+                return null;
+            }
+        }));
+        return [rootEntry, ...output]
+            .filter((value) => value !== null)
+            .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
+    }
+}

package/dist/server/server/platform/catalog/profile-command.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const localAvailability = {
+    codexProfileAvailable: () => !spawnSync('codex-profile', ['--version'], { stdio: 'ignore' }).error,
+    gestaltHomeExists: () => existsSync(join(homedir(), '.codex-gestalt')),
+};
+export function profileAppServerCommand(_profile, availability = localAvailability) {
+    void _profile;
+    return availability.codexProfileAvailable() && availability.gestaltHomeExists()
+        ? { command: 'codex-profile', args: ['cli', 'gestalt', 'app-server', '--stdio'] }
+        : { command: 'codex', args: ['app-server', '--stdio'] };
+}

package/dist/server/server/platform/catalog/workspace-id.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createHash } from 'node:crypto';
+export function workspaceId(path) {
+    return createHash('sha256').update(path).digest('base64url');
+}

package/dist/server/server/platform/codex/approval-policy.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function requiresApproval(policy, requested) {
+    return policy !== 'never' && requested;
+}

package/dist/server/server/platform/codex/codex-process-launcher.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { spawn } from 'node:child_process';
+import { JsonRpcClient } from './json-rpc-client.js';
+import { profileAppServerCommand } from '../catalog/profile-command.js';
+export function launchCodexAppServer(input) {
+    const launch = profileAppServerCommand(input.profile);
+    const child = spawn(launch.command, launch.args, {
+        cwd: input.cwd,
+        shell: false,
+        stdio: 'pipe',
+    });
+    const rpc = new JsonRpcClient(child.stdout, child.stdin);
+    child.once('error', (error) => rpc.fail(error));
+    return {
+        child,
+        rpc,
+        close: () => child.kill('SIGTERM'),
+        onExit: (listener) => {
+            child.once('exit', listener);
+            return () => child.off('exit', listener);
+        },
+    };
+}

package/dist/server/server/platform/codex/error-code.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function protocolErrorCode(installed, expected) {
+    if (!installed)
+        return 'CODEX_NOT_FOUND';
+    return installed === expected ? null : 'CODEX_PROTOCOL_MISMATCH';
+}

package/dist/server/server/platform/codex/json-rpc-client.js

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createInterface } from 'node:readline';
+export class JsonRpcClient {
+    output;
+    sequence = 0;
+    pending = new Map();
+    notifications = new Set();
+    serverRequests = new Set();
+    failure = null;
+    constructor(input, output) {
+        this.output = output;
+        createInterface({ input, crlfDelay: Infinity }).on('line', (line) => this.receive(line));
+    }
+    request(method, params) {
+        if (this.failure)
+            return Promise.reject(this.failure);
+        const id = ++this.sequence;
+        this.output.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+        return new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+    }
+    fail(error) {
+        if (this.failure)
+            return;
+        this.failure = error;
+        for (const { reject } of this.pending.values())
+            reject(error);
+        this.pending.clear();
+    }
+    onNotification(listener) {
+        this.notifications.add(listener);
+        return () => this.notifications.delete(listener);
+    }
+    onServerRequest(listener) {
+        this.serverRequests.add(listener);
+        return () => this.serverRequests.delete(listener);
+    }
+    receive(line) {
+        try {
+            const message = JSON.parse(line);
+            if (message.id === undefined) {
+                if (message.method)
+                    this.notifications.forEach((listener) => listener({ method: message.method, params: message.params }));
+                return;
+            }
+            if (message.method) {
+                const listener = this.serverRequests.values().next().value;
+                if (!listener)
+                    return;
+                void Promise.resolve(listener({ id: message.id, method: message.method, params: message.params }))
+                    .then((result) => this.output.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result })}\n`))
+                    .catch((error) => this.output.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, error: { message: error instanceof Error ? error.message : 'REQUEST_FAILED' } })}\n`));
+                return;
+            }
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                return;
+            this.pending.delete(message.id);
+            if (message.error)
+                pending.reject(message.error);
+            else
+                pending.resolve(message.result);
+        }
+        catch {
+            /* malformed protocol messages are ignored at this boundary */
+        }
+    }
+}