Class WorkspaceShellRouter

packages/computer/src/workspace.ts:1002–1124

// expects a WorkspaceShell without having to thread the union
// type through.
class WorkspaceShellRouter {
  readonly #defaultId: string;
  readonly #shellFor: (id: string) => Promise<{ shell: WorkspaceShell; handle: BackendHandle }>;
  readonly #resolveId: (id: string | undefined) => string;
  readonly #onError: (id: string, handle: BackendHandle, error: unknown) => void;

  constructor(
    defaultId: string,
    shellFor: (id: string) => Promise<{ shell: WorkspaceShell; handle: BackendHandle }>,
    resolveId: (id: string | undefined) => string,
    onError: (id: string, handle: BackendHandle, error: unknown) => void,
  ) {
    this.#defaultId = defaultId;
    this.#shellFor = shellFor;
    this.#resolveId = resolveId;
    this.#onError = onError;
  }

  async exec(command: string, options: { backend?: string } & Record<string, unknown> = {}) {
    const id = this.#resolveId(options.backend) || this.#defaultId;
    // Capture the BackendHandle here, at dispatch time. A late
    // failure from this command's stream must invalidate THIS
    // handle, not whatever the cache holds when the rejection
    // eventually fires; a concurrent reconnect may have already
    // swapped in a newer handle that we must not clobber.
    const { shell, handle: dispatchHandle } = await this.#shellFor(id);
    const { backend: _backend, ...rest } = options;
    let execHandle: unknown;
    try {
      execHandle = await (shell.exec as unknown as (c: string, o: typeof rest) => Promise<unknown>)(
        command,
        rest,
      );
    } catch (error) {
      this.#onError(id, dispatchHandle, error);
      throw error;
    }
    return this.#wrapHandle(id, dispatchHandle, execHandle);
  }

  async get(id: string, options: { backend?: string } & Record<string, unknown> = {}) {
    const backendId = this.#resolveId(options.backend) || this.#defaultId;
    const { shell, handle: dispatchHandle } = await this.#shellFor(backendId);
    const { backend: _backend, ...rest } = options;
    let execHandle: unknown;
    try {
      execHandle = await (shell.get as unknown as (e: string, o: typeof rest) => Promise<unknown>)(
        id,
        rest,
      );
    } catch (error) {
      this.#onError(backendId, dispatchHandle, error);
      throw error;
    }
    return this.#wrapHandle(backendId, dispatchHandle, execHandle);
  }

  async kill(