Class WorkspaceRuntime

packages/computer/src/runtime/runtime.ts:23–172

}

export class WorkspaceRuntime {
  readonly #options: WorkspaceRuntimeRouterOptions;

  constructor(options: WorkspaceRuntimeRouterOptions) {
    this.#options = options;
  }

  exec(source: string): Promise<WorkspaceRuntimeExecHandle<undefined>>;
  exec(
    source: string,
    options: WorkspaceRuntimeExecOptions<"utf8">,
  ): Promise<WorkspaceRuntimeExecHandle<"utf8">>;
  exec(
    source: string,
    options: WorkspaceRuntimeExecOptions<undefined>,
  ): Promise<WorkspaceRuntimeExecHandle<undefined>>;
  async exec<E extends ExecEncoding>(
    source: string,
    options: WorkspaceRuntimeExecOptions<E> = {},
  ): Promise<WorkspaceRuntimeExecHandle<E>> {
    if (options.id !== undefined) assertExecutionId(options.id);
    const backend = this.#backend(options.backend);
    if (options.input !== undefined && !this.#options.callableBackendIds.has(backend)) {
      throw new Error(
        `Backend ${JSON.stringify(backend)} is not callable; it does not accept structured input.`,
      );
    }
    if (this.#options.commandBackendIds.has(backend)) {
      if (options.input !== undefined) {
        throw new Error(
          `Backend ${JSON.stringify(backend)} is not callable; it does not accept structured input.`,
        );
      }
      const shell = this.#options.shell();
      const handle = await (
        shell.exec as unknown as (
          command: string,
          options: Record<string, unknown>,
        ) => Promise<ExecHandle<E>>
      )(source, {
        backend,
        cwd: options.cwd,
        encoding: options.encoding,
        id: options.id,
        timeoutMs: options.timeoutMs,
        env: options.env,
        stdin: options.stdin,
      });
      return wrapCommandHandle(handle, backend);
    }

    const runtime = await this.#options.moduleHandle(backend);
    const envelope = await runtime.exec({
      id: options.id,
      source,
      cwd: options.cwd,
      input: options.input,
      env: options.env,