kurtosis-sdk 0.49.5

package/build/core/lib/modules/module_context.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleContext = void 0;
+const neverthrow_1 = require("neverthrow");
+const constructor_calls_1 = require("../constructor_calls");
+// Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+class ModuleContext {
+    constructor(client, moduleId) {
+        this.moduleId = moduleId;
+        this.client = client;
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    execute(serializedParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const executeModuleArgs = (0, constructor_calls_1.newExecuteModuleArgs)(this.moduleId, serializedParams);
+            const executeResponseResult = yield this.client.executeModule(executeModuleArgs);
+            if (executeResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(executeResponseResult.error);
+            }
+            const executeResponse = executeResponseResult.value;
+            return (0, neverthrow_1.ok)(executeResponse.getSerializedResult());
+        });
+    }
+}
+exports.ModuleContext = ModuleContext;

package/build/core/lib/services/container_config.d.ts

@@ -0,0 +1,39 @@
+import { PortSpec } from "./port_spec";
+export declare type FilesArtifactUUID = string;
+export declare class ContainerConfig {
+    readonly image: string;
+    readonly usedPorts: Map<string, PortSpec>;
+    readonly publicPorts: Map<string, PortSpec>;
+    readonly filesArtifactMountpoints: Map<FilesArtifactUUID, string>;
+    readonly entrypointOverrideArgs: string[];
+    readonly cmdOverrideArgs: string[];
+    readonly environmentVariableOverrides: Map<string, string>;
+    readonly cpuAllocationMillicpus: number;
+    readonly memoryAllocationMegabytes: number;
+    readonly privateIPAddrPlaceholder: string;
+    constructor(image: string, usedPorts: Map<string, PortSpec>, publicPorts: Map<string, PortSpec>, //TODO this is a huge hack to temporarily enable static ports for NEAR until we have a more productized solution
+    filesArtifactMountpoints: Map<FilesArtifactUUID, string>, entrypointOverrideArgs: string[], cmdOverrideArgs: string[], environmentVariableOverrides: Map<string, string>, cpuAllocationMillicpus: number, memoryAllocationMegabytes: number, privateIPAddrPlaceholder: string);
+}
+export declare class ContainerConfigBuilder {
+    private readonly image;
+    private usedPorts;
+    private publicPorts;
+    private filesArtifactMountpoints;
+    private entrypointOverrideArgs;
+    private cmdOverrideArgs;
+    private environmentVariableOverrides;
+    private cpuAllocationMillicpus;
+    private memoryAllocationMegabytes;
+    private privateIPAddrPlaceholder;
+    constructor(image: string);
+    withUsedPorts(usedPorts: Map<string, PortSpec>): ContainerConfigBuilder;
+    withFiles(filesArtifactMountpoints: Map<FilesArtifactUUID, string>): ContainerConfigBuilder;
+    withEntrypointOverride(args: string[]): ContainerConfigBuilder;
+    withCmdOverride(args: string[]): ContainerConfigBuilder;
+    withEnvironmentVariableOverrides(envVars: Map<string, string>): ContainerConfigBuilder;
+    withPublicPorts(publicPorts: Map<string, PortSpec>): ContainerConfigBuilder;
+    withCpuAllocationMillicpus(cpuAllocationMillicpus: number): ContainerConfigBuilder;
+    withMemoryAllocationMegabytes(memoryAllocationMegabytes: number): ContainerConfigBuilder;
+    withPrivateIPAddrPlaceholder(privateIPAddrPlaceholder: string): ContainerConfigBuilder;
+    build(): ContainerConfig;
+}

package/build/core/lib/services/container_config.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerConfigBuilder = exports.ContainerConfig = void 0;
+const DEFAULT_PRIVATE_IP_ADDR_PLACEHOLDER = "KURTOSIS_PRIVATE_IP_ADDR_PLACEHOLDER";
+// ====================================================================================================
+//                                    Config Object
+// ====================================================================================================
+// TODO defensive copy when we're giving back complex objects?????
+// Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+class ContainerConfig {
+    constructor(image, usedPorts, publicPorts, //TODO this is a huge hack to temporarily enable static ports for NEAR until we have a more productized solution
+    filesArtifactMountpoints, entrypointOverrideArgs, cmdOverrideArgs, environmentVariableOverrides, cpuAllocationMillicpus, memoryAllocationMegabytes, privateIPAddrPlaceholder) {
+        this.image = image;
+        this.usedPorts = usedPorts;
+        this.publicPorts = publicPorts;
+        this.filesArtifactMountpoints = filesArtifactMountpoints;
+        this.entrypointOverrideArgs = entrypointOverrideArgs;
+        this.cmdOverrideArgs = cmdOverrideArgs;
+        this.environmentVariableOverrides = environmentVariableOverrides;
+        this.cpuAllocationMillicpus = cpuAllocationMillicpus;
+        this.memoryAllocationMegabytes = memoryAllocationMegabytes;
+        this.privateIPAddrPlaceholder = privateIPAddrPlaceholder;
+    }
+}
+exports.ContainerConfig = ContainerConfig;
+// ====================================================================================================
+//                                        Builder
+// ====================================================================================================
+// TODO Defensive copies on all these With... functions???
+// Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+class ContainerConfigBuilder {
+    constructor(image) {
+        this.image = image;
+        this.usedPorts = new Map();
+        this.filesArtifactMountpoints = new Map();
+        this.entrypointOverrideArgs = [];
+        this.cmdOverrideArgs = [];
+        this.environmentVariableOverrides = new Map();
+        this.publicPorts = new Map(); //TODO this is a huge hack to temporarily enable static ports for NEAR until we have a more productized solution
+        this.cpuAllocationMillicpus = 0;
+        this.memoryAllocationMegabytes = 0;
+        this.privateIPAddrPlaceholder = DEFAULT_PRIVATE_IP_ADDR_PLACEHOLDER;
+    }
+    withUsedPorts(usedPorts) {
+        this.usedPorts = usedPorts;
+        return this;
+    }
+    withFiles(filesArtifactMountpoints) {
+        this.filesArtifactMountpoints = filesArtifactMountpoints;
+        return this;
+    }
+    withEntrypointOverride(args) {
+        this.entrypointOverrideArgs = args;
+        return this;
+    }
+    withCmdOverride(args) {
+        this.cmdOverrideArgs = args;
+        return this;
+    }
+    withEnvironmentVariableOverrides(envVars) {
+        this.environmentVariableOverrides = envVars;
+        return this;
+    }
+    //TODO this is a huge hack to temporarily enable static ports for NEAR until we have a more productized solution
+    withPublicPorts(publicPorts) {
+        this.publicPorts = publicPorts;
+        return this;
+    }
+    withCpuAllocationMillicpus(cpuAllocationMillicpus) {
+        this.cpuAllocationMillicpus = cpuAllocationMillicpus;
+        return this;
+    }
+    withMemoryAllocationMegabytes(memoryAllocationMegabytes) {
+        this.memoryAllocationMegabytes = memoryAllocationMegabytes;
+        return this;
+    }
+    withPrivateIPAddrPlaceholder(privateIPAddrPlaceholder) {
+        this.privateIPAddrPlaceholder = privateIPAddrPlaceholder;
+        return this;
+    }
+    build() {
+        return new ContainerConfig(this.image, this.usedPorts, this.publicPorts, this.filesArtifactMountpoints, this.entrypointOverrideArgs, this.cmdOverrideArgs, this.environmentVariableOverrides, this.cpuAllocationMillicpus, this.memoryAllocationMegabytes, this.privateIPAddrPlaceholder);
+    }
+}
+exports.ContainerConfigBuilder = ContainerConfigBuilder;

package/build/core/lib/services/port_spec.d.ts

@@ -0,0 +1,11 @@
+import { Port } from "../../kurtosis_core_rpc_api_bindings/api_container_service_pb";
+export declare type PortProtocol = Port.Protocol;
+export declare namespace PortProtocol {
+    const TCP = Port.Protocol.TCP;
+    const UDP = Port.Protocol.UDP;
+}
+export declare class PortSpec {
+    readonly number: number;
+    readonly protocol: PortProtocol;
+    constructor(number: number, protocol: PortProtocol);
+}

package/build/core/lib/services/port_spec.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortSpec = exports.PortProtocol = void 0;
+const api_container_service_pb_1 = require("../../kurtosis_core_rpc_api_bindings/api_container_service_pb");
+var PortProtocol;
+(function (PortProtocol) {
+    PortProtocol.TCP = api_container_service_pb_1.Port.Protocol.TCP;
+    PortProtocol.UDP = api_container_service_pb_1.Port.Protocol.UDP;
+})(PortProtocol = exports.PortProtocol || (exports.PortProtocol = {}));
+class PortSpec {
+    constructor(number, protocol) {
+        this.number = number;
+        this.protocol = protocol;
+    }
+}
+exports.PortSpec = PortSpec;

package/build/core/lib/services/service.d.ts

@@ -0,0 +1 @@
+export declare type ServiceID = string;

package/build/core/lib/services/service.js

@@ -0,0 +1,6 @@
+"use strict";
+/*
+ * Copyright (c) 2020 - present Kurtosis Technologies LLC.
+ * All Rights Reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/core/lib/services/service_context.d.ts

@@ -0,0 +1,19 @@
+import { Result } from 'neverthrow';
+import type { PortSpec } from './port_spec';
+import type { ServiceID } from './service';
+import { GenericApiContainerClient } from '../enclaves/generic_api_container_client';
+export declare class ServiceContext {
+    private readonly client;
+    private readonly serviceId;
+    private readonly privateIpAddress;
+    private readonly privatePorts;
+    private readonly publicIpAddress;
+    private readonly publicPorts;
+    constructor(client: GenericApiContainerClient, serviceId: ServiceID, privateIpAddress: string, privatePorts: Map<string, PortSpec>, publicIpAddress: string, publicPorts: Map<string, PortSpec>);
+    getServiceID(): ServiceID;
+    getPrivateIPAddress(): string;
+    getPrivatePorts(): Map<string, PortSpec>;
+    getMaybePublicIPAddress(): string;
+    getPublicPorts(): Map<string, PortSpec>;
+    execCommand(command: string[]): Promise<Result<[number, string], Error>>;
+}

package/build/core/lib/services/service_context.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceContext = void 0;
+const neverthrow_1 = require("neverthrow");
+const constructor_calls_1 = require("../constructor_calls");
+// Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+class ServiceContext {
+    constructor(client, serviceId, privateIpAddress, privatePorts, publicIpAddress, publicPorts) {
+        this.client = client;
+        this.serviceId = serviceId;
+        this.privateIpAddress = privateIpAddress;
+        this.privatePorts = privatePorts;
+        this.publicIpAddress = publicIpAddress;
+        this.publicPorts = publicPorts;
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getServiceID() {
+        return this.serviceId;
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getPrivateIPAddress() {
+        return this.privateIpAddress;
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getPrivatePorts() {
+        return this.privatePorts;
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getMaybePublicIPAddress() {
+        return this.publicIpAddress;
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    getPublicPorts() {
+        return this.publicPorts;
+    }
+    // Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+    execCommand(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const execCommandArgs = (0, constructor_calls_1.newExecCommandArgs)(this.serviceId, command);
+            const execCommandResponseResult = yield this.client.execCommand(execCommandArgs);
+            if (execCommandResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(execCommandResponseResult.error);
+            }
+            const execCommandResponse = execCommandResponseResult.value;
+            return (0, neverthrow_1.ok)([execCommandResponse.getExitCode(), execCommandResponse.getLogOutput()]);
+        });
+    }
+}
+exports.ServiceContext = ServiceContext;

package/build/core/module_launch_api/args_io.d.ts

@@ -0,0 +1,4 @@
+import { Result } from "neverthrow";
+import { ModuleContainerArgs } from "./module_container_args";
+export declare function getEnvFromArgs(args: ModuleContainerArgs): Result<Map<string, string>, Error>;
+export declare function getArgsFromEnv(): Result<ModuleContainerArgs, Error>;

package/build/core/module_launch_api/args_io.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgsFromEnv = exports.getEnvFromArgs = void 0;
+const loglevel_1 = require("loglevel");
+const neverthrow_1 = require("neverthrow");
+// All module containers accept exactly one environment variable, which contains the serialized params that
+// dictate how the module container ought to behave
+const SERIALIZED_ARGS_ENV_VAR = "SERIALIZED_ARGS";
+const JAVASCRIPT_STRING_VAR_TYPE = "string";
+const safeJsonParse = neverthrow_1.Result.fromThrowable(JSON.parse, (value) => {
+    if (value instanceof Error) {
+        return value;
+    }
+    return new Error("Received an unknown exception value that wasn't an error: " + value);
+});
+// Intended to be used when starting the container - gets the environment variables that the container should be started with
+function getEnvFromArgs(args) {
+    let argsStr;
+    try {
+        argsStr = JSON.stringify(args);
+    }
+    catch (jsonErr) {
+        // Sadly, we have to do this because there's no great way to enforce the caught thing being an error
+        // See: https://stackoverflow.com/questions/30469261/checking-for-typeof-error-in-js
+        if (jsonErr && jsonErr.stack && jsonErr.message) {
+            return (0, neverthrow_1.err)(jsonErr);
+        }
+        return (0, neverthrow_1.err)(new Error("Stringify-ing ModuleContainerArgs object threw an exception, but " +
+            "it's not an Error so we can't report any more information than this"));
+    }
+    const result = new Map();
+    result.set(SERIALIZED_ARGS_ENV_VAR, argsStr);
+    return (0, neverthrow_1.ok)(result);
+}
+exports.getEnvFromArgs = getEnvFromArgs;
+function getArgsFromEnv() {
+    const serializedParamsStr = process.env[SERIALIZED_ARGS_ENV_VAR];
+    if (serializedParamsStr === undefined) {
+        return (0, neverthrow_1.err)(new Error(`No serialized args variable '${SERIALIZED_ARGS_ENV_VAR}' defined`));
+    }
+    if (serializedParamsStr === "") {
+        return (0, neverthrow_1.err)(new Error(`Found serialized args environment variable '${SERIALIZED_ARGS_ENV_VAR}', but the value was empty`));
+    }
+    const deserializationResult = safeJsonParse(serializedParamsStr);
+    if (deserializationResult.isErr()) {
+        // TODO Replace with a stacktrace.Propagate equivalent
+        loglevel_1.default.error(`An error occurred deserializing the args JSON '${serializedParamsStr}'`);
+        return (0, neverthrow_1.err)(deserializationResult.error);
+    }
+    const args = deserializationResult.value;
+    // Generic validation based on field type
+    for (let [key, value] of Object.entries(args)) {
+        // Ensure no empty strings
+        if (typeof value === JAVASCRIPT_STRING_VAR_TYPE && value.trim() === "") {
+            return (0, neverthrow_1.err)(new Error(`JSON field '${key}' is whitespace or empty string`));
+        }
+    }
+    return (0, neverthrow_1.ok)(args);
+}
+exports.getArgsFromEnv = getArgsFromEnv;

package/build/core/module_launch_api/module_container_args.d.ts

@@ -0,0 +1,8 @@
+export declare class ModuleContainerArgs {
+    readonly enclaveId: string;
+    readonly listenPortNum: number;
+    readonly apiContainerSocket: string;
+    readonly serializedCustomParams: string;
+    readonly enclaveDataDirMountpoint: string;
+    constructor(enclaveId: string, listenPortNum: number, apiContainerSocket: string, serializedCustomParams: string, enclaveDataDirMountpoint: string);
+}

package/build/core/module_launch_api/module_container_args.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleContainerArgs = void 0;
+class ModuleContainerArgs {
+    constructor(
+    // The ID of the enclave that the module will run inside
+    enclaveId, 
+    // The port number that the module should listen on
+    listenPortNum, 
+    // IP:port of the Kurtosis API container
+    apiContainerSocket, 
+    // Arbitrary serialized data that the module can consume at startup to modify its behaviour
+    // Analogous to the "constructor"
+    serializedCustomParams, 
+    // The location on the module container where the enclave data directory has been mounted during launch
+    enclaveDataDirMountpoint) {
+        this.enclaveId = enclaveId;
+        this.listenPortNum = listenPortNum;
+        this.apiContainerSocket = apiContainerSocket;
+        this.serializedCustomParams = serializedCustomParams;
+        this.enclaveDataDirMountpoint = enclaveDataDirMountpoint;
+    }
+}
+exports.ModuleContainerArgs = ModuleContainerArgs;

package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_grpc_pb.d.ts

@@ -0,0 +1,50 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// package: engine_api
+// file: engine_service.proto
+
+import * as engine_service_pb from "./engine_service_pb";
+import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
+import * as grpc from "@grpc/grpc-js";
+
+interface IEngineServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  getEngineInfo: grpc.MethodDefinition<google_protobuf_empty_pb.Empty, engine_service_pb.GetEngineInfoResponse>;
+  createEnclave: grpc.MethodDefinition<engine_service_pb.CreateEnclaveArgs, engine_service_pb.CreateEnclaveResponse>;
+  getEnclaves: grpc.MethodDefinition<google_protobuf_empty_pb.Empty, engine_service_pb.GetEnclavesResponse>;
+  stopEnclave: grpc.MethodDefinition<engine_service_pb.StopEnclaveArgs, google_protobuf_empty_pb.Empty>;
+  destroyEnclave: grpc.MethodDefinition<engine_service_pb.DestroyEnclaveArgs, google_protobuf_empty_pb.Empty>;
+  clean: grpc.MethodDefinition<engine_service_pb.CleanArgs, engine_service_pb.CleanResponse>;
+}
+
+export const EngineServiceService: IEngineServiceService;
+
+export interface IEngineServiceServer extends grpc.UntypedServiceImplementation {
+  getEngineInfo: grpc.handleUnaryCall<google_protobuf_empty_pb.Empty, engine_service_pb.GetEngineInfoResponse>;
+  createEnclave: grpc.handleUnaryCall<engine_service_pb.CreateEnclaveArgs, engine_service_pb.CreateEnclaveResponse>;
+  getEnclaves: grpc.handleUnaryCall<google_protobuf_empty_pb.Empty, engine_service_pb.GetEnclavesResponse>;
+  stopEnclave: grpc.handleUnaryCall<engine_service_pb.StopEnclaveArgs, google_protobuf_empty_pb.Empty>;
+  destroyEnclave: grpc.handleUnaryCall<engine_service_pb.DestroyEnclaveArgs, google_protobuf_empty_pb.Empty>;
+  clean: grpc.handleUnaryCall<engine_service_pb.CleanArgs, engine_service_pb.CleanResponse>;
+}
+
+export class EngineServiceClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  getEngineInfo(argument: google_protobuf_empty_pb.Empty, callback: grpc.requestCallback<engine_service_pb.GetEngineInfoResponse>): grpc.ClientUnaryCall;
+  getEngineInfo(argument: google_protobuf_empty_pb.Empty, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.GetEngineInfoResponse>): grpc.ClientUnaryCall;
+  getEngineInfo(argument: google_protobuf_empty_pb.Empty, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.GetEngineInfoResponse>): grpc.ClientUnaryCall;
+  createEnclave(argument: engine_service_pb.CreateEnclaveArgs, callback: grpc.requestCallback<engine_service_pb.CreateEnclaveResponse>): grpc.ClientUnaryCall;
+  createEnclave(argument: engine_service_pb.CreateEnclaveArgs, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.CreateEnclaveResponse>): grpc.ClientUnaryCall;
+  createEnclave(argument: engine_service_pb.CreateEnclaveArgs, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.CreateEnclaveResponse>): grpc.ClientUnaryCall;
+  getEnclaves(argument: google_protobuf_empty_pb.Empty, callback: grpc.requestCallback<engine_service_pb.GetEnclavesResponse>): grpc.ClientUnaryCall;
+  getEnclaves(argument: google_protobuf_empty_pb.Empty, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.GetEnclavesResponse>): grpc.ClientUnaryCall;
+  getEnclaves(argument: google_protobuf_empty_pb.Empty, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.GetEnclavesResponse>): grpc.ClientUnaryCall;
+  stopEnclave(argument: engine_service_pb.StopEnclaveArgs, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  stopEnclave(argument: engine_service_pb.StopEnclaveArgs, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  stopEnclave(argument: engine_service_pb.StopEnclaveArgs, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  destroyEnclave(argument: engine_service_pb.DestroyEnclaveArgs, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  destroyEnclave(argument: engine_service_pb.DestroyEnclaveArgs, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  destroyEnclave(argument: engine_service_pb.DestroyEnclaveArgs, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  clean(argument: engine_service_pb.CleanArgs, callback: grpc.requestCallback<engine_service_pb.CleanResponse>): grpc.ClientUnaryCall;
+  clean(argument: engine_service_pb.CleanArgs, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.CleanResponse>): grpc.ClientUnaryCall;
+  clean(argument: engine_service_pb.CleanArgs, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<engine_service_pb.CleanResponse>): grpc.ClientUnaryCall;
+}

package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_grpc_pb.js

@@ -0,0 +1,186 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var engine_service_pb = require('./engine_service_pb.js');
+var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js');
+
+function serialize_engine_api_CleanArgs(arg) {
+  if (!(arg instanceof engine_service_pb.CleanArgs)) {
+    throw new Error('Expected argument of type engine_api.CleanArgs');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_CleanArgs(buffer_arg) {
+  return engine_service_pb.CleanArgs.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_engine_api_CleanResponse(arg) {
+  if (!(arg instanceof engine_service_pb.CleanResponse)) {
+    throw new Error('Expected argument of type engine_api.CleanResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_CleanResponse(buffer_arg) {
+  return engine_service_pb.CleanResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_engine_api_CreateEnclaveArgs(arg) {
+  if (!(arg instanceof engine_service_pb.CreateEnclaveArgs)) {
+    throw new Error('Expected argument of type engine_api.CreateEnclaveArgs');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_CreateEnclaveArgs(buffer_arg) {
+  return engine_service_pb.CreateEnclaveArgs.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_engine_api_CreateEnclaveResponse(arg) {
+  if (!(arg instanceof engine_service_pb.CreateEnclaveResponse)) {
+    throw new Error('Expected argument of type engine_api.CreateEnclaveResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_CreateEnclaveResponse(buffer_arg) {
+  return engine_service_pb.CreateEnclaveResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_engine_api_DestroyEnclaveArgs(arg) {
+  if (!(arg instanceof engine_service_pb.DestroyEnclaveArgs)) {
+    throw new Error('Expected argument of type engine_api.DestroyEnclaveArgs');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_DestroyEnclaveArgs(buffer_arg) {
+  return engine_service_pb.DestroyEnclaveArgs.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_engine_api_GetEnclavesResponse(arg) {
+  if (!(arg instanceof engine_service_pb.GetEnclavesResponse)) {
+    throw new Error('Expected argument of type engine_api.GetEnclavesResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_GetEnclavesResponse(buffer_arg) {
+  return engine_service_pb.GetEnclavesResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_engine_api_GetEngineInfoResponse(arg) {
+  if (!(arg instanceof engine_service_pb.GetEngineInfoResponse)) {
+    throw new Error('Expected argument of type engine_api.GetEngineInfoResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_GetEngineInfoResponse(buffer_arg) {
+  return engine_service_pb.GetEngineInfoResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_engine_api_StopEnclaveArgs(arg) {
+  if (!(arg instanceof engine_service_pb.StopEnclaveArgs)) {
+    throw new Error('Expected argument of type engine_api.StopEnclaveArgs');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_engine_api_StopEnclaveArgs(buffer_arg) {
+  return engine_service_pb.StopEnclaveArgs.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_google_protobuf_Empty(arg) {
+  if (!(arg instanceof google_protobuf_empty_pb.Empty)) {
+    throw new Error('Expected argument of type google.protobuf.Empty');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_google_protobuf_Empty(buffer_arg) {
+  return google_protobuf_empty_pb.Empty.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+var EngineServiceService = exports.EngineServiceService = {
+  // Endpoint for getting information about the engine, which is also what we use to verify that the engine has become available
+getEngineInfo: {
+    path: '/engine_api.EngineService/GetEngineInfo',
+    requestStream: false,
+    responseStream: false,
+    requestType: google_protobuf_empty_pb.Empty,
+    responseType: engine_service_pb.GetEngineInfoResponse,
+    requestSerialize: serialize_google_protobuf_Empty,
+    requestDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_engine_api_GetEngineInfoResponse,
+    responseDeserialize: deserialize_engine_api_GetEngineInfoResponse,
+  },
+  // ==============================================================================================
+//                                   Enclave Management
+// ==============================================================================================
+// Creates a new Kurtosis Enclave
+createEnclave: {
+    path: '/engine_api.EngineService/CreateEnclave',
+    requestStream: false,
+    responseStream: false,
+    requestType: engine_service_pb.CreateEnclaveArgs,
+    responseType: engine_service_pb.CreateEnclaveResponse,
+    requestSerialize: serialize_engine_api_CreateEnclaveArgs,
+    requestDeserialize: deserialize_engine_api_CreateEnclaveArgs,
+    responseSerialize: serialize_engine_api_CreateEnclaveResponse,
+    responseDeserialize: deserialize_engine_api_CreateEnclaveResponse,
+  },
+  // Returns information about the existing enclaves
+getEnclaves: {
+    path: '/engine_api.EngineService/GetEnclaves',
+    requestStream: false,
+    responseStream: false,
+    requestType: google_protobuf_empty_pb.Empty,
+    responseType: engine_service_pb.GetEnclavesResponse,
+    requestSerialize: serialize_google_protobuf_Empty,
+    requestDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_engine_api_GetEnclavesResponse,
+    responseDeserialize: deserialize_engine_api_GetEnclavesResponse,
+  },
+  // Stops all containers in an enclave
+stopEnclave: {
+    path: '/engine_api.EngineService/StopEnclave',
+    requestStream: false,
+    responseStream: false,
+    requestType: engine_service_pb.StopEnclaveArgs,
+    responseType: google_protobuf_empty_pb.Empty,
+    requestSerialize: serialize_engine_api_StopEnclaveArgs,
+    requestDeserialize: deserialize_engine_api_StopEnclaveArgs,
+    responseSerialize: serialize_google_protobuf_Empty,
+    responseDeserialize: deserialize_google_protobuf_Empty,
+  },
+  // Destroys an enclave, removing all artifacts associated with it
+destroyEnclave: {
+    path: '/engine_api.EngineService/DestroyEnclave',
+    requestStream: false,
+    responseStream: false,
+    requestType: engine_service_pb.DestroyEnclaveArgs,
+    responseType: google_protobuf_empty_pb.Empty,
+    requestSerialize: serialize_engine_api_DestroyEnclaveArgs,
+    requestDeserialize: deserialize_engine_api_DestroyEnclaveArgs,
+    responseSerialize: serialize_google_protobuf_Empty,
+    responseDeserialize: deserialize_google_protobuf_Empty,
+  },
+  // Gets rid of old enclaves
+clean: {
+    path: '/engine_api.EngineService/Clean',
+    requestStream: false,
+    responseStream: false,
+    requestType: engine_service_pb.CleanArgs,
+    responseType: engine_service_pb.CleanResponse,
+    requestSerialize: serialize_engine_api_CleanArgs,
+    requestDeserialize: deserialize_engine_api_CleanArgs,
+    responseSerialize: serialize_engine_api_CleanResponse,
+    responseDeserialize: deserialize_engine_api_CleanResponse,
+  },
+};
+
+exports.EngineServiceClient = grpc.makeGenericClientConstructor(EngineServiceService);