Class WorkspaceRuntimeCapability

packages/computer/src/runtime/capability.ts:7–239

} from "./types.js";

export class WorkspaceRuntimeCapability {
  readonly #fs: WorkspaceRuntimeFilesystem;
  readonly #root: string;
  readonly #access: WorkspaceRuntimeAccess;
  readonly #maxReadBytes: number;
  readonly #maxDirectoryEntries: number;

  constructor(
    fs: WorkspaceRuntimeFilesystem,
    root: string,
    access: WorkspaceRuntimeAccess,
    maxReadBytes = 1024 * 1024,
    maxDirectoryEntries = 1024,
  ) {
    this.#fs = fs;
    this.#root = normalizeRoot(root);
    this.#access = access;
    this.#maxReadBytes = maxReadBytes;
    this.#maxDirectoryEntries = maxDirectoryEntries;
  }

  get access(): WorkspaceRuntimeAccess {
    return this.#access;
  }

  async readFile(path: string) {
    const resolved = await this.#resolveSafe(path);
    await this.#assertReadableSize(resolved);
    return this.#fs.readFile(resolved, "utf8");
  }

  async readFileBytes(path: string) {
    const resolved = await this.#resolveSafe(path);
    await this.#assertReadableSize(resolved);
    const stream = await this.#fs.readFile(resolved);
    const reader = stream.getReader();
    const chunks: Uint8Array[] = [];
    let size = 0;
    try {
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        size += value.byteLength;
        if (size > this.#maxReadBytes) {
          await reader.cancel("Workspace runtime file read limit exceeded");
          throw new Error(`Workspace runtime file read exceeds ${this.#maxReadBytes} bytes.`);
        }
        chunks.push(value);
      }
    } finally {
      reader.releaseLock();
    }
    const bytes = new Uint8Array(size);
    let offset = 0;
    for (const chunk of chunks) {
      bytes.set(chunk, offset);
      offset += chunk.byteLength;
    }