@innovatorstack/harness 0.0.0-stage → 0.1.0

package/src/methods/csharp/executor.ts

@@ -0,0 +1,504 @@
+import { requestOperationsMax } from "../../core/limits.js";
+import { Item } from "../../items/item.js";
+import { ApplicationError, PlatformError } from "../../platform/errors.js";
+import type { MethodDefinition, MethodExecutor, MethodPorts } from "../types.js";
+import { managedCallback, requestChange } from "./callbacks.js";
+import type { ManagedCallbackState } from "./callbacks.js";
+import { CSharpCompiler } from "./compiler.js";
+import type { CompiledMethod, CSharpOptions } from "./compiler.js";
+import { ManagedInput, managedFailure } from "./context.js";
+import { ManagedOrigins } from "./origins.js";
+import { encodeMessage, pendingCallsMax, messageBytesMax } from "./protocol.js";
+import { ManagedSecurity } from "./security.js";
+import { acquireWorker, releaseWorker } from "./worker.js";
+import type { ManagedProcess, ManagedWorker } from "./worker.js";
+
+const assembliesMax = 2048;
+
+interface PendingInvocation {
+    failure?: { readonly error: unknown };
+    received: boolean;
+    started: boolean;
+    readonly security: ManagedSecurity;
+    readonly origins: ManagedOrigins;
+    callbackCount: number;
+    readonly input: ManagedInput;
+    readonly ports: MethodPorts;
+    readonly resolve: (item: Item) => void;
+    readonly reject: (error: unknown) => void;
+    readonly timer: ReturnType<typeof setTimeout>;
+}
+
+export class CSharpExecutor implements MethodExecutor {
+    readonly language = "C#";
+    private readonly compiler: CSharpCompiler;
+    private worker: ManagedProcess | undefined;
+    private transport: ManagedWorker | undefined;
+    private workerKey = "";
+    private readonly loadedAssemblies = new Set<string>();
+    private readonly callbacks = new Set<string>();
+    private queuedBytes = 0;
+    private writes: Promise<void> = Promise.resolve();
+    private readonly pending = new Map<string, PendingInvocation>();
+    private nextId = 0;
+    private generation = 0;
+    private starting: Promise<void> | undefined;
+
+    constructor(options: CSharpOptions = {}) {
+        this.compiler = new CSharpCompiler(options);
+    }
+
+    async execute(method: MethodDefinition, context: Item, ports: MethodPorts): Promise<Item> {
+        const generation = this.generation;
+        const host = await this.compiler.host();
+        await this.start(host);
+        const compiled = await this.compiler.method(
+            method,
+            host,
+            ports.eventData?.kind ?? ports.serverEvent?.name,
+        );
+
+        if (generation !== this.generation) {
+            throw new PlatformError("ExecutorReset", "C# executor was reset during compilation.");
+        }
+
+        if (this.pending.size >= pendingCallsMax || this.nextId >= Number.MAX_SAFE_INTEGER) {
+            throw new PlatformError("ProtocolLimit", "The C# invocation limit was reached.");
+        }
+
+        if (
+            !this.loadedAssemblies.has(compiled.assembly) &&
+            this.loadedAssemblies.size >= assembliesMax
+        ) {
+            throw new PlatformError(
+                "ProtocolLimit",
+                "Reset the world before loading more C# Methods.",
+            );
+        }
+
+        this.loadedAssemblies.add(compiled.assembly);
+        const id = String(++this.nextId);
+        const origins = new ManagedOrigins();
+        const input = new ManagedInput(context, origins);
+
+        return await new Promise<Item>((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.timeout(id, method.name);
+            }, this.compiler.timeoutMs);
+            this.pending.set(id, {
+                input,
+                ports,
+                resolve: deferNativeCompletion(resolve),
+                reject: deferNativeCompletion(reject),
+                timer,
+                received: false,
+                started: false,
+                callbackCount: 0,
+                security: new ManagedSecurity(),
+                origins,
+            });
+
+            try {
+                this.invoke(id, compiled, context, ports, input);
+            } catch (error) {
+                this.stop(error);
+            }
+        });
+    }
+
+    private timeout(id: string, method: string): void {
+        const invocation = this.pending.get(id);
+        let phase = "worker receipt";
+
+        if (invocation?.received) {
+            phase = "Method loading";
+        }
+
+        if (invocation?.started) {
+            phase = "source execution";
+        }
+
+        this.stop(
+            new PlatformError(
+                "MethodTimeout",
+                `Method '${method}' exceeded ${this.compiler.timeoutMs}ms during ${phase}.`,
+                {
+                    cause: new Error(
+                        JSON.stringify({
+                            received: invocation?.received ?? false,
+                            sourceStarted: invocation?.started ?? false,
+                            callbacks: invocation?.callbackCount ?? 0,
+                            pendingCallbacks: this.callbacks.size,
+                            queuedBytes: this.queuedBytes,
+                            workerExitCode: this.worker?.exitCode ?? null,
+                        }),
+                    ),
+                },
+            ),
+        );
+    }
+
+    reset(): void {
+        this.stop(new PlatformError("ExecutorReset", "C# executor was reset."), true);
+    }
+
+    dispose(): void {
+        this.stop(new PlatformError("ExecutorClosed", "C# executor was closed."), true);
+    }
+
+    private async start(host: string): Promise<void> {
+        if (this.worker) {
+            return;
+        }
+
+        const starting = this.starting ?? this.connect(host);
+        this.starting = starting;
+
+        try {
+            await starting;
+        } finally {
+            if (this.starting === starting) {
+                this.starting = undefined;
+            }
+        }
+    }
+
+    private async connect(host: string): Promise<void> {
+        const generation = this.generation;
+        const transport = await acquireWorker(this.compiler.dotnet, host, this.compiler.references);
+
+        if (generation !== this.generation) {
+            transport.close();
+
+            throw new PlatformError(
+                "ExecutorReset",
+                "C# executor was reset during worker acquisition.",
+            );
+        }
+
+        const worker = transport.process;
+        this.transport = transport;
+        this.workerKey = JSON.stringify([this.compiler.dotnet, host, this.compiler.references]);
+        this.worker = worker;
+        this.writes = Promise.resolve();
+        transport.attach({
+            message: (message) => {
+                if (this.worker === worker) {
+                    this.receive(message, worker);
+                }
+            },
+
+            failed: (error) => {
+                if (this.worker === worker) {
+                    this.stop(error);
+                }
+            },
+        });
+    }
+
+    private invoke(
+        id: string,
+        compiled: CompiledMethod,
+        context: Item,
+        ports: MethodPorts,
+        input: ManagedInput,
+    ): void {
+        if (!this.transport) {
+            throw new PlatformError(
+                "WorkerUnavailable",
+                "The C# worker has no invocation transport.",
+            );
+        }
+
+        this.transport.expectInvocation(id);
+        this.send({
+            kind: "invoke",
+            id,
+            ...compiled,
+            context: context.payload,
+            contextOrigins: input.frame,
+            document: input.document,
+            ...(ports.eventData ? { eventData: ports.eventData } : {}),
+        });
+    }
+
+    private send(message: unknown): void {
+        const worker = this.worker;
+
+        if (!worker) {
+            throw new PlatformError("WorkerUnavailable", "The C# worker is not running.");
+        }
+
+        const bytes = encodeMessage(message);
+
+        if (this.queuedBytes + bytes.length > messageBytesMax * 2) {
+            throw new PlatformError("ProtocolLimit", "The C# outgoing queue is full.");
+        }
+
+        this.queuedBytes += bytes.length;
+        this.writes = this.writes
+            .then(async () => {
+                if (this.worker !== worker) {
+                    return;
+                }
+
+                try {
+                    await worker.stdin.write(bytes);
+                    await worker.stdin.flush();
+                } finally {
+                    if (this.worker === worker) {
+                        this.queuedBytes -= bytes.length;
+                    }
+                }
+            })
+            .catch((error: unknown) => {
+                if (this.worker === worker) {
+                    this.stop(error);
+                }
+            });
+    }
+
+    private receive(message: Record<string, unknown>, worker: ManagedProcess): void {
+        if (message.kind === "received") {
+            const pending =
+                typeof message.id === "string" ? this.pending.get(message.id) : undefined;
+
+            if (!pending || pending.received) {
+                throw new PlatformError(
+                    "InvalidProtocol",
+                    "Unknown or duplicate C# invocation receipt.",
+                );
+            }
+
+            pending.received = true;
+        } else if (message.kind === "started") {
+            const pending =
+                typeof message.id === "string" ? this.pending.get(message.id) : undefined;
+
+            if (!pending || pending.started) {
+                throw new PlatformError(
+                    "InvalidProtocol",
+                    "Unknown or duplicate C# invocation start.",
+                );
+            }
+
+            pending.started = true;
+            pending.ports.executionStarted?.();
+        } else if (message.kind === "callback") {
+            void this.callback(message, worker).catch((error: unknown) => {
+                if (this.worker === worker) {
+                    this.stop(error);
+                }
+            });
+        } else {
+            this.complete(message);
+        }
+    }
+
+    private complete(message: Record<string, unknown>): void {
+        const id = message.id;
+
+        if (typeof id !== "string") {
+            throw new PlatformError("InvalidProtocol", "Missing invocation ID.");
+        }
+
+        const pending = this.pending.get(id);
+
+        if (!pending) {
+            throw new PlatformError("InvalidProtocol", `Unknown C# invocation '${id}'.`);
+        }
+
+        if (message.kind !== "failure" && message.kind !== "result") {
+            throw new PlatformError("InvalidProtocol", "Unknown C# result kind.");
+        }
+
+        try {
+            pending.security[Symbol.dispose]();
+        } catch (error) {
+            pending.failure ??= { error };
+        }
+
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+
+        try {
+            pending.input.synchronize(message);
+
+            if (pending.failure !== undefined) {
+                throw pending.failure.error;
+            }
+
+            if (message.kind === "failure") {
+                throw managedFailure(message);
+            }
+
+            pending.resolve(new Item(pending.origins.decode(message.payload, message.origins)));
+        } catch (error) {
+            if (pending.failure !== undefined && pending.failure.error !== error) {
+                pending.reject(
+                    new AggregateError(
+                        [pending.failure.error, error],
+                        "Managed execution failed and its input could not be synchronized.",
+                    ),
+                );
+            } else {
+                pending.reject(error);
+            }
+        }
+    }
+
+    private async callback(
+        message: Record<string, unknown>,
+        worker: ManagedProcess,
+    ): Promise<void> {
+        const id = message.id;
+        const invocationId = message.invocationId;
+
+        if (typeof id !== "string" || typeof invocationId !== "string") {
+            throw new PlatformError("InvalidProtocol", "Missing callback identity.");
+        }
+
+        const pending = this.pending.get(invocationId);
+
+        if (!pending) {
+            throw new PlatformError(
+                "ExpiredCallback",
+                "C# callback refers to an expired invocation.",
+            );
+        }
+
+        pending.callbackCount += 1;
+
+        if (
+            !pending.started ||
+            pending.callbackCount > requestOperationsMax ||
+            this.callbacks.has(id) ||
+            this.callbacks.size >= pendingCallsMax
+        ) {
+            throw new PlatformError("ProtocolLimit", "The C# callback limit was reached.");
+        }
+
+        this.callbacks.add(id);
+        const state: ManagedCallbackState = { origins: pending.origins };
+
+        try {
+            const result = await managedCallback(message, pending.ports, pending.security, state);
+
+            if (this.worker === worker) {
+                this.send({
+                    kind: "callbackResult",
+                    id,
+                    payload: result.payload,
+                    requestChange: requestChange(state),
+                });
+            }
+        } catch (error) {
+            if (this.worker !== worker) {
+                return;
+            }
+
+            this.failCallback(error, pending, id, state);
+        } finally {
+            if (this.worker === worker) {
+                this.callbacks.delete(id);
+            }
+        }
+    }
+
+    private failCallback(
+        error: unknown,
+        pending: PendingInvocation,
+        id: string,
+        state: ManagedCallbackState,
+    ): void {
+        const response = { kind: "callbackResult", id, requestChange: requestChange(state) };
+
+        if (error instanceof ApplicationError) {
+            this.send({ ...response, payload: error.item.payload });
+
+            return;
+        }
+
+        pending.failure = { error };
+        const message = error instanceof Error ? error.message : String(error);
+
+        try {
+            pending.ports.fail(message);
+        } catch (failure) {
+            // fail() poisons the owning transaction and is required to throw.
+            pending.failure = { error: failure };
+        }
+
+        this.send({ ...response, error: message });
+    }
+
+    private stop(error: unknown, reuse = false): void {
+        this.generation += 1;
+        this.starting = undefined;
+        const transport = this.transport;
+        this.worker = undefined;
+        this.transport = undefined;
+
+        if (transport) {
+            this.releaseTransport(transport, error, reuse);
+        }
+
+        this.loadedAssemblies.clear();
+        this.callbacks.clear();
+        this.queuedBytes = 0;
+
+        for (const invocation of this.pending.values()) {
+            clearTimeout(invocation.timer);
+
+            try {
+                invocation.security[Symbol.dispose]();
+                invocation.reject(error);
+            } catch (cleanup) {
+                invocation.reject(
+                    new AggregateError(
+                        [error, cleanup],
+                        "Managed execution and grant cleanup failed.",
+                    ),
+                );
+            }
+        }
+
+        this.pending.clear();
+    }
+
+    private releaseTransport(transport: ManagedWorker, error: unknown, reuse: boolean): void {
+        if (
+            !reuse ||
+            !transport.available ||
+            !transport.reusable ||
+            this.compiler.references.length > 0
+        ) {
+            transport.close(error);
+
+            return;
+        }
+
+        if (this.pending.size === 0 && this.callbacks.size === 0 && this.queuedBytes === 0) {
+            releaseWorker(this.workerKey, transport);
+        } else {
+            transport.close(error);
+        }
+    }
+}
+
+export function csharp(options: CSharpOptions = {}): MethodExecutor {
+    return new CSharpExecutor(options);
+}
+
+/** Settle outside the Windows pipe callback so Bun's native matchers can reenter its loop. */
+function deferNativeCompletion<Value>(complete: (value: Value) => void): (value: Value) => void {
+    if (process.platform !== "win32") {
+        return complete;
+    }
+
+    return (value) => {
+        setTimeout(() => {
+            complete(value);
+        }, 0);
+    };
+}

package/src/methods/csharp/index.ts

@@ -0,0 +1,3 @@
+export { csharp, CSharpExecutor } from "./executor.js";
+export { CSharpCompiler } from "./compiler.js";
+export type { CSharpOptions } from "./compiler.js";

package/src/methods/csharp/method-build.ts

@@ -0,0 +1,141 @@
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import { readBinaryFile, readTextFile } from "../../core/files.js";
+import { PlatformError } from "../../platform/errors.js";
+import type { MethodDefinition } from "../types.js";
+
+const interopDirectory = Bun.fileURLToPath(new URL("managed/", import.meta.url));
+const hostIdentities = new Map<string, Promise<string>>();
+
+export async function methodBuildIdentity(
+    inputs: {
+        readonly method: MethodDefinition;
+        readonly host: string;
+        readonly source: string;
+        readonly event: string;
+    },
+    references: readonly string[],
+): Promise<string> {
+    const method = inputs.method;
+    const hash = new Bun.CryptoHasher("sha256")
+        .update("direct-shared-sdk-csc-v4")
+        .update(inputs.source)
+        .update(inputs.event)
+        .update(method.id)
+        .update(method.name)
+        .update(method.code)
+        .update(method.source.file)
+        .update(String(method.source.line))
+        .update(await hostIdentity(inputs.host))
+        .update(await readTextFile(join(interopDirectory, "GlobalUsings.cs.template")));
+
+    for (const reference of references) {
+        hash.update(reference).update(await readBinaryFile(reference));
+    }
+
+    return hash.digest("hex");
+}
+
+async function hostIdentity(host: string): Promise<string> {
+    const cached = hostIdentities.get(host);
+
+    if (cached) {
+        return await cached;
+    }
+
+    if (hostIdentities.size >= 16) {
+        hostIdentities.clear();
+    }
+
+    const pending = (async () => {
+        const contents = await Promise.all(
+            [
+                hostContract(host),
+                join(dirname(host), "Newtonsoft.Json.dll"),
+                join(dirname(host), "compiler-symbols.txt"),
+            ].map((path) => readBinaryFile(path)),
+        );
+        const hash = new Bun.CryptoHasher("sha256");
+
+        for (const bytes of contents) {
+            hash.update(String(bytes.length)).update(bytes);
+        }
+
+        return hash.digest("hex");
+    })();
+    hostIdentities.set(host, pending);
+
+    try {
+        return await pending;
+    } catch (error) {
+        hostIdentities.delete(host);
+
+        throw error;
+    }
+}
+
+export function hostContract(host: string): string {
+    return join(dirname(host), "ref", "InnovatorHarness.Managed.dll");
+}
+
+/** Use the installed SDK compiler directly; business Methods need no restore or MSBuild run. */
+export async function methodCompilerArguments(
+    host: string,
+    directory: string,
+    name: string,
+    references: readonly string[],
+): Promise<readonly string[]> {
+    const inputs = (await readTextFile(join(dirname(host), "compiler-inputs.txt")))
+        .split(/\r?\n/u)
+        .filter(Boolean);
+    const compiler = inputs[0];
+    const symbols = (await readTextFile(join(dirname(host), "compiler-symbols.txt")))
+        .split(/\r?\n/u)
+        .filter(Boolean);
+
+    if (!compiler || inputs.length < 2 || inputs.length > 1024) {
+        throw new PlatformError(
+            "CSharpUnavailable",
+            "The managed host has invalid SDK compiler inputs.",
+        );
+    }
+
+    await mkdir(join(directory, "bin"), { recursive: true });
+    await Bun.write(
+        join(directory, "GlobalUsings.cs"),
+        await readTextFile(join(interopDirectory, "GlobalUsings.cs.template")),
+    );
+    const arguments_ = [
+        "/nologo",
+        "/target:library",
+        "/nostdlib+",
+        "/deterministic+",
+        "/nullable:enable",
+        "/optimize+",
+        "/debug:portable",
+        "/langversion:latest",
+        `/define:${symbols.join(";")}`,
+        `/out:${join(directory, "bin", `${name}.dll`)}`,
+        ...[...inputs.slice(1), hostContract(host), ...references].map(
+            (path) => `/reference:${path}`,
+        ),
+        join(directory, "GlobalUsings.cs"),
+        join(directory, "Method.cs"),
+    ];
+    const response = join(directory, "compiler.rsp");
+    await Bun.write(response, arguments_.map(quoteArgument).join("\n"));
+
+    return [compiler, "/shared", `@${response}`];
+}
+
+function quoteArgument(value: string): string {
+    if (/[\r\n]/u.test(value)) {
+        throw new PlatformError(
+            "CSharpUnavailable",
+            "Compiler input paths cannot contain newlines.",
+        );
+    }
+
+    return `"${value.replaceAll(/(\\*)"/gu, '$1$1\\"').replace(/(\\+)$/u, "$1$1")}"`;
+}