Function exec

src/node/runtime/RemoteRuntime.ts:100–339

* Execute command with streaming I/O. * Shared implementation that delegates process spawning to subclass.

(command: string, options: ExecOptions)

   * Shared implementation that delegates process spawning to subclass.
   */
  async exec(command: string, options: ExecOptions): Promise<ExecStream> {
    const startTime = performance.now();

    // Short-circuit if already aborted
    if (options.abortSignal?.aborted) {
      throw new RuntimeError("Operation aborted before execution", "exec");
    }

    // Build command parts
    const parts: string[] = [];

    // Add cd command
    parts.push(this.cdCommand(options.cwd));

    // Add environment variable exports (user env first, then non-interactive overrides)
    const envVars = { ...options.env, ...NON_INTERACTIVE_ENV_VARS };
    for (const [key, value] of Object.entries(envVars)) {
      parts.push(buildShellExport(key, value, (envValue) => shescape.quote(envValue)));
    }

    // Add the actual command
    parts.push(command);

    // Join all parts with && to ensure each step succeeds before continuing
    let fullCommand = parts.join(" && ");

    // Wrap in bash for consistent shell behavior
    fullCommand = `bash -c ${shescape.quote(fullCommand)}`;

    // Optionally wrap with timeout
    if (options.timeout !== undefined) {
      const remoteTimeout = Math.ceil(options.timeout) + 1;
      fullCommand = `timeout -s KILL ${remoteTimeout} ${fullCommand}`;
    }

    // Spawn the remote process (SSH or Docker)
    const timeoutMs = options.timeout !== undefined ? options.timeout * 1000 : undefined;
    const deadlineMs = timeoutMs !== undefined ? Date.now() + timeoutMs : undefined;
    const spawnResult = await this.spawnRemoteProcess(fullCommand, {
      ...options,
      deadlineMs,
    });
    const { process: childProcess } = spawnResult;

    // Short-lived commands can close stdin before writes/close complete.
    if (childProcess.stdin) {
      attachStreamErrorHandler(childProcess.stdin, `${this.commandPrefix} stdin`, {
        logger: log,
      });
    }

    // Wrap in DisposableProcess for cleanup
    const disposable = new DisposableProcess(childProcess);

    // Track if we killed the process due to timeout or abort
    let timedOut = false;
    let aborted = false;