Class WorkspaceShell

packages/computer/src/shell.ts:145–231

}

export class WorkspaceShell {
  readonly #shell: ShellRPC;
  readonly #sync: Sync;
  readonly #observer: WorkspaceObserver;

  constructor(shell: ShellRPC, sync: Sync, observer: WorkspaceObserver = noopObserver) {
    this.#shell = shell;
    this.#sync = sync;
    this.#observer = observer;
  }

  exec(command: string): Promise<ExecHandle<undefined>>;
  exec(command: string, options: ExecOptions<undefined>): Promise<ExecHandle<undefined>>;
  exec(command: string, options: ExecOptions<"utf8">): Promise<ExecHandle<"utf8">>;
  async exec<E extends ExecEncoding>(
    command: string,
    options: ExecOptions<E> = {},
  ): Promise<ExecHandle<E>> {
    assertNotTemplate(command);
    // Pre-exec push: ship anything the host wrote since the last
    // push so the spawned command sees it. Failures non-fatal per
    // docs/05 — the command still runs; pushed reports 0.
    let pushed = 0;
    try {
      pushed = await this.#sync.push();
    } catch {
      // pushed stays 0
    }
    const envelope = await withSpan(
      this.#observer,
      "workspace.runtime.exec.spawn",
      {
        "workspace.runtime.cwd": options.cwd,
        "workspace.runtime.timeout_ms": options.timeoutMs,
        "workspace.runtime.id": options.id,
      },
      () =>
        this.#shell.exec({
          command,
          id: options.id,
          cwd: options.cwd,
          timeoutMs: options.timeoutMs,
          env: options.env,
          stdin:
            typeof options.stdin === "string"
              ? new TextEncoder().encode(options.stdin)
              : options.stdin,
        }),
      (span, outcome) => {
        if (outcome.ok) span.setAttribute("workspace.runtime.id", outcome.value.id);
      },
    );
    // Dispose the result envelope when the event stream finishes
    // draining. Without this, capnweb's exports table holds onto
    // the envelope for the life of the session — one entry per
    // exec call — because we hand the inner stream off to the
    // caller and can't `using` the envelope ourselves.
    const events = disposeOnDone(envelope.events, () => maybeDispose(envelope));