@code-yeongyu/senpi 2026.10.25-2 → 2026.10.25-4

package/dist/modes/rpc/mcp-presenter-authority.js

@@ -0,0 +1,309 @@
+import { randomUUID } from "node:crypto";
+import { queuedForm } from "../../core/extensions/builtin/mcp/modern/consent-queue.js";
+import { isRecord, validateMrtrForm } from "../../core/extensions/builtin/mcp/modern/form-schema.js";
+import { McpFormDialog, mcpFormClock } from "./mcp-form-dialog.js";
+/** Host-owned only. No public session command can call enrollment or install a registration. */
+export class McpPresenterAuthority {
+    constructor(options = {}) {
+        this.instance = randomUUID();
+        this.connections = new Map();
+        this.bindings = new Map();
+        this.registrations = new Map();
+        this.clock = options.clock ?? mcpFormClock;
+    }
+    dispose() {
+        for (const binding of [...this.bindings.values()])
+            binding.dispose();
+        this.connections.clear();
+        this.registrations.clear();
+    }
+    connect(id, send) {
+        const connection = { id, send, epoch: randomUUID(), nonce: randomUUID(), attachments: new Map() };
+        this.connections.set(connection, connection);
+        return connection;
+    }
+    attach(sender, handle) {
+        const connection = this.connections.get(sender);
+        const binding = [...this.bindings.values()].find((value) => value === handle);
+        if (connection && binding && !connection.attachments.has(binding))
+            connection.attachments.set(binding, { id: randomUUID(), epoch: randomUUID() });
+    }
+    connectionContext(sender, sessionId) {
+        const connection = this.connections.get(sender);
+        const binding = this.bindings.get(sessionId);
+        const attachment = binding && connection?.attachments.get(binding);
+        if (!connection || !binding || !attachment)
+            return undefined;
+        return {
+            hostInstance: this.instance,
+            connectionNonce: connection.nonce,
+            bindingEpoch: binding.epoch,
+            attachmentId: attachment.id,
+            attachmentEpoch: attachment.epoch,
+        };
+    }
+    detach(sender, handle) {
+        const connection = this.connections.get(sender);
+        if (!connection)
+            return;
+        for (const binding of connection.attachments.keys()) {
+            if (handle !== undefined && handle !== binding)
+                continue;
+            connection.attachments.delete(binding);
+            if (binding.grant?.registration.connection === connection)
+                this.revoke(binding.grant.registration);
+        }
+        if (handle === undefined)
+            this.connections.delete(sender);
+    }
+    withdraw(sender) {
+        const connection = this.connections.get(sender);
+        if (!connection)
+            return;
+        for (const binding of connection.attachments.keys())
+            if (binding.grant?.registration.connection === connection)
+                this.revoke(binding.grant.registration);
+    }
+    bind(sessionId, durableId, admit) {
+        this.bindings.get(sessionId)?.dispose();
+        const lifetime = new AbortController();
+        const binding = {
+            sessionId,
+            durableId,
+            admit,
+            epoch: randomUUID(),
+            lifetime,
+            signal: lifetime.signal,
+            listeners: new Set(),
+            version: () => (binding.grant && this.current(binding.grant) ? binding.grant.id : undefined),
+            subscribe: (listener) => {
+                binding.listeners.add(listener);
+                return () => {
+                    binding.listeners.delete(listener);
+                };
+            },
+            capture: () => {
+                const grant = binding.grant;
+                return grant && this.current(grant) ? this.presentation(grant) : undefined;
+            },
+            dispose: () => {
+                binding.lifetime.abort();
+                if (binding.grant)
+                    this.revoke(binding.grant.registration, true);
+                if (this.bindings.get(sessionId) === binding)
+                    this.bindings.delete(sessionId);
+                for (const connection of this.connections.values())
+                    connection.attachments.delete(binding);
+                binding.listeners.clear();
+            },
+        };
+        this.bindings.set(sessionId, binding);
+        return binding;
+    }
+    /** Called only after the protected bootstrap has pinned and authenticated its launch principal. */
+    enroll(principal = randomUUID()) {
+        const generation = randomUUID();
+        return {
+            register: (handle, sender, options) => {
+                const binding = [...this.bindings.values()].find((value) => value === handle);
+                const connection = this.connections.get(sender);
+                if (!binding || binding.grant || !connection?.attachments.has(binding))
+                    throw new Error("presenter_not_authorized");
+                const registration = {
+                    id: randomUUID(),
+                    principal,
+                    generation,
+                    binding,
+                    connection,
+                    kind: options.kind,
+                    active: true,
+                };
+                this.registrations.set(registration, registration);
+                return registration;
+            },
+            acquire: (handle) => {
+                const registration = this.registrations.get(handle);
+                if (!registration || registration.principal !== principal || !registration.active)
+                    throw new Error("presenter_not_authorized");
+                const { binding, connection } = registration;
+                const attachment = connection.attachments.get(binding);
+                if (!attachment || binding.lifetime.signal.aborted || binding.grant)
+                    throw new Error("presenter_not_authorized");
+                const scope = {
+                    hostInstance: this.instance,
+                    durableSessionId: binding.durableId,
+                    bindingEpoch: binding.epoch,
+                    attachmentId: attachment.id,
+                    attachmentEpoch: attachment.epoch,
+                    connectionId: connection.id,
+                    connectionEpoch: connection.epoch,
+                    presenterPrincipalId: principal,
+                    presenterGeneration: generation,
+                    presentationBindingId: registration.id,
+                    presenterKind: registration.kind,
+                    purpose: "mcp_form",
+                };
+                const grant = {
+                    id: randomUUID(),
+                    registration,
+                    scope,
+                    lifetime: new AbortController(),
+                    dialogs: new Map(),
+                };
+                binding.grant = grant;
+                for (const listener of binding.listeners)
+                    listener();
+                return { grantId: grant.id, scope };
+            },
+            revoke: (handle) => {
+                const registration = this.registrations.get(handle);
+                if (registration?.principal === principal)
+                    this.revoke(registration);
+            },
+        };
+    }
+    receive(sender, value) {
+        const connection = this.connections.get(sender);
+        const binding = isRecord(value) && typeof value.sessionId === "string" ? this.bindings.get(value.sessionId) : undefined;
+        const grant = binding?.grant;
+        // Check authority before parsing the private namespace, including invented dialog ids.
+        if (!connection || !grant || grant.registration.connection !== connection || !this.current(grant))
+            return { error: "presenter_not_authorized" };
+        if (!isRecord(value) ||
+            value.grantId !== grant.id ||
+            value.bindingEpoch !== grant.scope.bindingEpoch ||
+            value.attachmentEpoch !== grant.scope.attachmentEpoch)
+            return { error: "presenter_not_authorized" };
+        const allowed = [
+            "type",
+            "id",
+            "sessionId",
+            "bindingEpoch",
+            "attachmentEpoch",
+            "grantId",
+            "dialogId",
+            "dialogToken",
+            "formRevision",
+        ];
+        if (value.type === "mcp_form_response")
+            allowed.push("action", "content");
+        if (Object.keys(value).some((key) => !allowed.includes(key)))
+            return { error: "invalid_form_response" };
+        if (value.type === "mcp_form_sync") {
+            const form = grant.dialogs.values().next().value?.sync();
+            return form === undefined ? { ok: true } : { ok: true, form };
+        }
+        if (typeof value.dialogId !== "string" ||
+            typeof value.dialogToken !== "string" ||
+            typeof value.formRevision !== "string")
+            return { error: "invalid_form_response" };
+        const dialog = grant.dialogs.get(value.dialogId);
+        if (!dialog)
+            return { error: "form_stale" };
+        if (!dialog.matches(value.dialogToken, value.formRevision))
+            return { error: "invalid_form_response" };
+        switch (value.type) {
+            case "mcp_form_presented":
+                return dialog.presented();
+            case "mcp_form_response":
+                return typeof value.action === "string"
+                    ? dialog.respond(value.action, value.content)
+                    : { error: "invalid_form_response" };
+            default:
+                return { error: "invalid_form_response" };
+        }
+    }
+    current(grant) {
+        const { registration, scope } = grant;
+        const { binding, connection } = registration;
+        return (registration.active &&
+            !binding.lifetime.signal.aborted &&
+            !grant.lifetime.signal.aborted &&
+            this.bindings.get(binding.sessionId) === binding &&
+            binding.grant === grant &&
+            this.connections.get(connection) === connection &&
+            connection.attachments.get(binding)?.epoch === scope.attachmentEpoch);
+    }
+    revoke(registration, operation = false) {
+        registration.active = false;
+        this.registrations.delete(registration);
+        const binding = registration.binding;
+        const grant = binding.grant;
+        if (!grant || grant.registration !== registration)
+            return;
+        binding.grant = undefined;
+        for (const listener of binding.listeners)
+            listener();
+        // Retain entry references after authority is fenced. Cleanup never validates the revoked sender.
+        for (const dialog of [...grant.dialogs.values()])
+            dialog.terminate(operation ? "operation_aborted" : "presentation_lost");
+        grant.lifetime.abort();
+    }
+    presentation(grant) {
+        return {
+            signal: grant.lifetime.signal,
+            ready: () => this.current(grant),
+            present: (input) => this.present(grant, input),
+        };
+    }
+    present(grant, input) {
+        const unavailable = {
+            kind: "processing_failure",
+            source: "host_termination",
+            humanAdmission: false,
+        };
+        if (!this.current(grant) ||
+            !validateMrtrForm(input.schema) ||
+            Object.keys(input.schema.properties).length > 64 ||
+            Buffer.byteLength(JSON.stringify({ message: input.message, schema: input.schema })) > 512 * 1024)
+            return Promise.resolve(unavailable);
+        const binding = grant.registration.binding;
+        const deadline = this.clock.now() + input.deadlineMs;
+        const expired = new AbortController();
+        const timer = this.clock.schedule(() => expired.abort(), Math.max(0, input.deadlineMs));
+        const signal = AbortSignal.any([
+            input.operationSignal,
+            input.presentationSignal,
+            grant.lifetime.signal,
+            expired.signal,
+        ]);
+        return queuedForm(grant, signal, () => {
+            this.clock.cancel(timer);
+            if (!this.current(grant))
+                return Promise.resolve(unavailable);
+            const dialogId = randomUUID();
+            const dialog = new McpFormDialog({
+                ...input,
+                presentationSignal: signal,
+                deadlineMs: Math.max(0, deadline - this.clock.now()),
+            }, {
+                clock: this.clock,
+                envelope: {
+                    sessionId: binding.sessionId,
+                    bindingEpoch: binding.epoch,
+                    attachmentEpoch: grant.scope.attachmentEpoch,
+                    grantId: grant.id,
+                    dialogId,
+                    formRevision: randomUUID(),
+                },
+                current: () => this.current(grant),
+                remove: () => {
+                    grant.dialogs.delete(dialogId);
+                },
+                admit: binding.admit,
+                send: grant.registration.connection.send,
+            });
+            grant.dialogs.set(dialogId, dialog);
+            dialog.start();
+            return dialog.result;
+        })
+            .catch(() => ({
+            ...unavailable,
+            kind: input.operationSignal.aborted || binding.signal.aborted || input.operationCurrent?.() === false
+                ? "operation_aborted"
+                : "processing_failure",
+        }))
+            .finally(() => this.clock.cancel(timer));
+    }
+}
+//# sourceMappingURL=mcp-presenter-authority.js.map

package/dist/modes/rpc/mcp-presenter-bootstrap.d.ts

@@ -0,0 +1,8 @@
+import type { ChildProcess } from "node:child_process";
+import { Duplex } from "node:stream";
+export declare const MCP_PRESENTER_BOOTSTRAP_FD = 4;
+/** The descriptor is not authority: only this live channel's enrollment transcript can issue grants. */
+export declare function presenterBootstrapStream(fd: number): Duplex | undefined;
+/** Relay one bounded enrollment exchange; fd 3 and stdin are never touched. */
+export declare function relayPresenterBootstrap(upstream: Duplex, child: ChildProcess): Promise<void>;
+//# sourceMappingURL=mcp-presenter-bootstrap.d.ts.map

package/dist/modes/rpc/mcp-presenter-bootstrap.js

@@ -0,0 +1,111 @@
+import { createReadStream, fstatSync, write } from "node:fs";
+import { Socket } from "node:net";
+import { Duplex } from "node:stream";
+import { attachJsonlLineReader } from "./jsonl.js";
+export const MCP_PRESENTER_BOOTSTRAP_FD = 4;
+/** The descriptor is not authority: only this live channel's enrollment transcript can issue grants. */
+export function presenterBootstrapStream(fd) {
+    if (fd !== MCP_PRESENTER_BOOTSTRAP_FD)
+        return undefined;
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isSocket() && !stat.isFIFO())
+            return undefined;
+    }
+    catch {
+        // Bootstrap is optional authority, never a reason to terminate the shared host.
+        return undefined;
+    }
+    // One stream owns the descriptor. Separate read/write stream destructors can close it twice.
+    const input = createReadStream("", { fd, autoClose: true });
+    const stream = new Duplex({
+        read() {
+            input.resume();
+        },
+        write(chunk, _encoding, done) {
+            if (chunk.length === 0) {
+                done();
+                return;
+            }
+            const send = (offset) => {
+                write(fd, chunk, offset, chunk.length - offset, null, (error, count) => {
+                    if (error)
+                        done(error);
+                    else if (count === 0)
+                        done(new Error("presenter_bootstrap_write_failed"));
+                    else if (offset + count === chunk.length)
+                        done();
+                    else
+                        send(offset + count);
+                });
+            };
+            send(0);
+        },
+        destroy(error, done) {
+            if (input.closed)
+                done(error);
+            else {
+                input.once("close", () => done(error));
+                input.destroy();
+            }
+        },
+    });
+    input.on("data", (chunk) => {
+        if (!stream.push(chunk))
+            input.pause();
+    });
+    input.on("end", () => stream.push(null));
+    input.on("error", (error) => stream.destroy(error));
+    return stream;
+}
+/** Relay one bounded enrollment exchange; fd 3 and stdin are never touched. */
+export function relayPresenterBootstrap(upstream, child) {
+    const downstream = child.stdio[MCP_PRESENTER_BOOTSTRAP_FD];
+    if (!(downstream instanceof Socket)) {
+        upstream.destroy();
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        let ended = false;
+        let acknowledging = false;
+        const finish = () => {
+            if (ended)
+                return;
+            ended = true;
+            clearTimeout(timer);
+            unreadUp();
+            unreadDown();
+            upstream.destroy();
+            downstream.destroy();
+            resolve();
+        };
+        const timer = setTimeout(finish, 30_000);
+        const unreadUp = attachJsonlLineReader(upstream, (line) => {
+            if (!downstream.write(`${line}\n`))
+                finish();
+        }, { maxLineLength: 16 * 1024, onOversizedLine: finish });
+        const unreadDown = attachJsonlLineReader(downstream, (line) => {
+            try {
+                const record = JSON.parse(line);
+                acknowledging =
+                    typeof record === "object" && record !== null && "type" in record && record.type === "enrolled";
+                upstream.write(`${line}\n`, () => {
+                    if (acknowledging)
+                        finish();
+                });
+            }
+            catch {
+                finish();
+            }
+        }, { maxLineLength: 16 * 1024, onOversizedLine: finish });
+        upstream.once("error", finish);
+        downstream.once("error", finish);
+        upstream.once("end", finish);
+        downstream.once("end", () => {
+            if (!acknowledging)
+                finish();
+        });
+        child.once("exit", finish);
+    });
+}
+//# sourceMappingURL=mcp-presenter-bootstrap.js.map

package/dist/modes/rpc/mcp-presenter-control.d.ts

@@ -0,0 +1,24 @@
+import { Duplex } from "node:stream";
+import type { SessionEventWriter } from "./session-event-writer.ts";
+/** Separate authenticated control endpoint. Ordinary RPC credentials cannot enroll or acquire. */
+export declare class McpPresenterControl {
+    private readonly writer;
+    private readonly authority;
+    private readonly principals;
+    private readonly controls;
+    private readonly revokeControls;
+    private launchOwner?;
+    private readonly backendGenerations;
+    private readonly successors;
+    private readonly server;
+    readonly path: string;
+    constructor(writer: SessionEventWriter, path: string);
+    listen(): Promise<void>;
+    /** A deferred handover is spawned by the old host, not the CLI that already returned. */
+    successorBootstrap(): Duplex | undefined;
+    /** Only the inherited launch channel may introduce the installation public key. */
+    bootstrap(stream: Duplex): void;
+    dispose(): void;
+    private manage;
+}
+//# sourceMappingURL=mcp-presenter-control.d.ts.map