Class WorkspaceFileStore

packages/computer/src/tools/fs/store.ts:37–118

}

export class WorkspaceFileStore implements FileStore {
  constructor(private readonly ws: WorkspaceLike) {}

  async stat(path: string): Promise<FileStat | null> {
    try {
      const s = await this.ws.fs.stat(path);
      if (!s.isFile) return null;
      return { size: s.size, mtime: s.mtime, mode: s.mode };
    } catch (err) {
      if (isEnoent(err)) return null;
      throw err;
    }
  }

  async readAll(path: string): Promise<Uint8Array | null> {
    try {
      const stream = await this.ws.fs.readFile(path);
      return await drain(stream);
    } catch (err) {
      if (isEnoent(err)) return null;
      throw err;
    }
  }

  async write(path: string, content: Uint8Array, opts?: { mode?: number }): Promise<void> {
    await ensureParentDir(this.ws, path);
    await this.ws.fs.writeFile(path, content, opts);
  }

  async *readChunks(path: string, byteOffset = 0, byteLength?: number): AsyncIterable<Uint8Array> {
    if (byteOffset < 0) throw new Error("readChunks: byteOffset must be non-negative");
    if (byteLength !== undefined && byteLength < 0) {
      throw new Error("readChunks: byteLength must be non-negative");
    }
    if (byteLength === 0) return;

    const stream = await this.ws.fs.readFile(path);
    const reader = stream.getReader();
    let skipped = 0;
    let yielded = 0;
    let completed = false;
    try {
      while (true) {
        const { value, done } = await reader.read();
        if (done) {
          completed = true;
          break;
        }
        if (!value || value.byteLength === 0) continue;

        let start = 0;
        if (skipped < byteOffset) {
          const needed = byteOffset - skipped;
          if (value.byteLength <= needed) {
            skipped += value.byteLength;
            continue;
          }
          start = needed;