@loopstack/sandbox-filesystem 0.5.5 → 0.5.7

package/package.json

@@ -7,7 +7,7 @@
     "filesystem",
     "sandbox"
   ],
-  "version": "0.5.5",
+  "version": "0.5.7",
   "license": "MIT",
   "author": {
     "name": "Tobias Blättermann, Jakob Klippel"
@@ -15,8 +15,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./src/*": "./src/*"
+    ".": "./dist/index.js"
   },
   "scripts": {
     "build": "nest build",
@@ -27,14 +26,13 @@
     "watch": "nest build --watch"
   },
   "dependencies": {
-    "@loopstack/common": "^0.27.0",
-    "@loopstack/sandbox-tool": "^0.5.5",
+    "@loopstack/common": "^0.29.0",
+    "@loopstack/sandbox-tool": "^0.5.7",
     "@nestjs/common": "^11.1.19",
     "zod": "^4.3.6"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "jest": {
     "testEnvironment": "node",
@@ -55,7 +53,6 @@
       }
     ],
     "installModes": [
-      "add",
       "install"
     ]
   }

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './sandbox-filesystem.module';
-export * from './tools/sandbox-read-file.tool';
-export * from './tools/sandbox-write-file.tool';
-export * from './tools/sandbox-list-directory.tool';
-export * from './tools/sandbox-create-directory.tool';
-export * from './tools/sandbox-delete.tool';
-export * from './tools/sandbox-exists.tool';
-export * from './tools/sandbox-file-info.tool';

package/src/sandbox-filesystem.module.ts

@@ -1,32 +0,0 @@
-import { Module } from '@nestjs/common';
-import { SandboxToolModule } from '@loopstack/sandbox-tool';
-import { SandboxCreateDirectory } from './tools/sandbox-create-directory.tool';
-import { SandboxDelete } from './tools/sandbox-delete.tool';
-import { SandboxExists } from './tools/sandbox-exists.tool';
-import { SandboxFileInfo } from './tools/sandbox-file-info.tool';
-import { SandboxListDirectory } from './tools/sandbox-list-directory.tool';
-import { SandboxReadFile } from './tools/sandbox-read-file.tool';
-import { SandboxWriteFile } from './tools/sandbox-write-file.tool';
-
-@Module({
-  imports: [SandboxToolModule],
-  providers: [
-    SandboxReadFile,
-    SandboxWriteFile,
-    SandboxListDirectory,
-    SandboxCreateDirectory,
-    SandboxDelete,
-    SandboxExists,
-    SandboxFileInfo,
-  ],
-  exports: [
-    SandboxReadFile,
-    SandboxWriteFile,
-    SandboxListDirectory,
-    SandboxCreateDirectory,
-    SandboxDelete,
-    SandboxExists,
-    SandboxFileInfo,
-  ],
-})
-export class SandboxFilesystemModule {}

package/src/tools/sandbox-create-directory.tool.ts

@@ -1,73 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { z } from 'zod';
-import { BaseTool, InjectTool, Tool, ToolResult } from '@loopstack/common';
-import { SandboxCommand } from '@loopstack/sandbox-tool';
-
-const inputSchema = z
-  .object({
-    containerId: z.string().describe('The ID of the container to create the directory in'),
-    path: z.string().describe('The path of the directory to create'),
-    recursive: z.boolean().default(true).describe("Whether to create parent directories if they don't exist"),
-  })
-  .strict();
-
-type SandboxCreateDirectoryArgs = z.infer<typeof inputSchema>;
-
-interface SandboxCreateDirectoryResult {
-  path: string;
-  created: boolean;
-}
-
-@Tool({
-  uiConfig: {
-    description: 'Create a directory in a sandbox container',
-  },
-  schema: inputSchema,
-})
-export class SandboxCreateDirectory extends BaseTool {
-  private readonly logger = new Logger(SandboxCreateDirectory.name);
-
-  @InjectTool() private sandboxCommand: SandboxCommand;
-
-  async call(args: SandboxCreateDirectoryArgs): Promise<ToolResult<SandboxCreateDirectoryResult>> {
-    const { containerId, path: dirPath, recursive } = args;
-
-    this.logger.debug(`Creating directory ${dirPath} in container ${containerId} (recursive: ${recursive})`);
-
-    const mkdirArgs = recursive ? ['-p', dirPath] : [dirPath];
-
-    const result = await this.sandboxCommand.call({
-      containerId,
-      executable: 'mkdir',
-      args: mkdirArgs,
-      workingDirectory: '/',
-      timeout: 10000,
-    });
-
-    if (!result.data) {
-      this.logger.error(`Failed to create directory ${dirPath}: No result data`);
-      throw new Error(`Failed to create directory ${dirPath}: No result data`);
-    }
-
-    // Exit code 0 means success, exit code 1 with "File exists" is okay if directory already exists
-    const alreadyExists = result.data.exitCode !== 0 && result.data.stderr.includes('File exists');
-
-    if (result.data.exitCode !== 0 && !alreadyExists) {
-      this.logger.error(`Failed to create directory ${dirPath}: ${result.data.stderr || 'Unknown error'}`);
-      throw new Error(`Failed to create directory ${dirPath}: ${result.data.stderr || 'Unknown error'}`);
-    }
-
-    if (alreadyExists) {
-      this.logger.debug(`Directory ${dirPath} already exists`);
-    } else {
-      this.logger.log(`Successfully created directory ${dirPath} in container ${containerId}`);
-    }
-
-    return {
-      data: {
-        path: dirPath,
-        created: result.data.exitCode === 0,
-      },
-    };
-  }
-}

package/src/tools/sandbox-delete.tool.ts

@@ -1,70 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { z } from 'zod';
-import { BaseTool, InjectTool, Tool, ToolResult } from '@loopstack/common';
-import { SandboxCommand } from '@loopstack/sandbox-tool';
-
-const inputSchema = z
-  .object({
-    containerId: z.string().describe('The ID of the container to delete the file/directory from'),
-    path: z.string().describe('The path to the file or directory to delete'),
-    recursive: z.boolean().default(false).describe('Whether to recursively delete directories and their contents'),
-    force: z.boolean().default(false).describe('Whether to force deletion without prompting for confirmation'),
-  })
-  .strict();
-
-type SandboxDeleteArgs = z.infer<typeof inputSchema>;
-
-interface SandboxDeleteResult {
-  path: string;
-  deleted: boolean;
-}
-
-@Tool({
-  uiConfig: {
-    description: 'Delete a file or directory in a sandbox container',
-  },
-  schema: inputSchema,
-})
-export class SandboxDelete extends BaseTool {
-  private readonly logger = new Logger(SandboxDelete.name);
-
-  @InjectTool() private sandboxCommand: SandboxCommand;
-
-  async call(args: SandboxDeleteArgs): Promise<ToolResult<SandboxDeleteResult>> {
-    const { containerId, path: targetPath, recursive, force } = args;
-
-    this.logger.debug(`Deleting ${targetPath} in container ${containerId} (recursive: ${recursive}, force: ${force})`);
-
-    const rmArgs: string[] = [];
-    if (recursive) rmArgs.push('-r');
-    if (force) rmArgs.push('-f');
-    rmArgs.push(targetPath);
-
-    const result = await this.sandboxCommand.call({
-      containerId,
-      executable: 'rm',
-      args: rmArgs,
-      workingDirectory: '/',
-      timeout: 30000,
-    });
-
-    if (!result.data) {
-      this.logger.error(`Failed to delete ${targetPath}: No result data`);
-      throw new Error(`Failed to delete ${targetPath}: No result data`);
-    }
-
-    if (result.data.exitCode !== 0) {
-      this.logger.error(`Failed to delete ${targetPath}: ${result.data.stderr || 'Unknown error'}`);
-      throw new Error(`Failed to delete ${targetPath}: ${result.data.stderr || 'Unknown error'}`);
-    }
-
-    this.logger.log(`Successfully deleted ${targetPath} in container ${containerId}`);
-
-    return {
-      data: {
-        path: targetPath,
-        deleted: true,
-      },
-    };
-  }
-}

package/src/tools/sandbox-exists.tool.ts

@@ -1,86 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { z } from 'zod';
-import { BaseTool, InjectTool, Tool, ToolResult } from '@loopstack/common';
-import { SandboxCommand } from '@loopstack/sandbox-tool';
-
-const inputSchema = z
-  .object({
-    containerId: z.string().describe('The ID of the container to check for file existence'),
-    path: z.string().describe('The path to check for existence'),
-  })
-  .strict();
-
-type SandboxExistsArgs = z.infer<typeof inputSchema>;
-
-interface SandboxExistsResult {
-  path: string;
-  exists: boolean;
-  type: 'file' | 'directory' | 'symlink' | 'other' | null;
-}
-
-@Tool({
-  uiConfig: {
-    description: 'Check if a file or directory exists in a sandbox container',
-  },
-  schema: inputSchema,
-})
-export class SandboxExists extends BaseTool {
-  private readonly logger = new Logger(SandboxExists.name);
-
-  @InjectTool()
-  private sandboxCommand: SandboxCommand;
-
-  async call(args: SandboxExistsArgs): Promise<ToolResult<SandboxExistsResult>> {
-    const { containerId, path: targetPath } = args;
-
-    this.logger.debug(`Checking existence of ${targetPath} in container ${containerId}`);
-
-    // Use test command to check existence and stat to get type
-    const result = await this.sandboxCommand.call({
-      containerId,
-      executable: 'sh',
-      args: [
-        '-c',
-        `if [ -e '${targetPath.replace(/'/g, "'\\''")}' ]; then stat -c '%F' '${targetPath.replace(/'/g, "'\\''")}'; else echo 'NOT_FOUND'; fi`,
-      ],
-      workingDirectory: '/',
-      timeout: 10000,
-    });
-
-    if (!result.data) {
-      this.logger.error(`Failed to check existence of ${targetPath}: No result data`);
-      throw new Error(`Failed to check existence of ${targetPath}: No result data`);
-    }
-
-    if (result.data.exitCode !== 0) {
-      this.logger.error(`Failed to check existence of ${targetPath}: ${result.data.stderr || 'Unknown error'}`);
-      throw new Error(`Failed to check existence of ${targetPath}: ${result.data.stderr || 'Unknown error'}`);
-    }
-
-    const output = result.data.stdout.trim();
-    const exists = output !== 'NOT_FOUND';
-
-    let type: SandboxExistsResult['type'] = null;
-    if (exists) {
-      type = this.parseFileType(output);
-    }
-
-    this.logger.debug(`Path ${targetPath} exists: ${exists}${exists ? `, type: ${type}` : ''}`);
-
-    return {
-      data: {
-        path: targetPath,
-        exists,
-        type,
-      },
-    };
-  }
-
-  private parseFileType(statOutput: string): SandboxExistsResult['type'] {
-    const lower = statOutput.toLowerCase();
-    if (lower.includes('regular')) return 'file';
-    if (lower.includes('directory')) return 'directory';
-    if (lower.includes('symbolic link')) return 'symlink';
-    return 'other';
-  }
-}

package/src/tools/sandbox-file-info.tool.ts

@@ -1,102 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { z } from 'zod';
-import { BaseTool, InjectTool, Tool, ToolResult } from '@loopstack/common';
-import { SandboxCommand } from '@loopstack/sandbox-tool';
-
-const inputSchema = z
-  .object({
-    containerId: z.string().describe('The ID of the container to get file info from'),
-    path: z.string().describe('The path to the file or directory'),
-  })
-  .strict();
-
-type SandboxFileInfoArgs = z.infer<typeof inputSchema>;
-
-interface SandboxFileInfoResult {
-  path: string;
-  name: string;
-  type: 'file' | 'directory' | 'symlink' | 'other';
-  size: number;
-  permissions: string;
-  owner: string;
-  group: string;
-  modifiedAt: string;
-  accessedAt: string;
-  createdAt: string;
-}
-
-@Tool({
-  uiConfig: {
-    description: 'Get detailed information about a file or directory in a sandbox container',
-  },
-  schema: inputSchema,
-})
-export class SandboxFileInfo extends BaseTool {
-  private readonly logger = new Logger(SandboxFileInfo.name);
-
-  @InjectTool() private sandboxCommand: SandboxCommand;
-
-  async call(args: SandboxFileInfoArgs): Promise<ToolResult<SandboxFileInfoResult>> {
-    const { containerId, path: targetPath } = args;
-
-    this.logger.debug(`Getting file info for ${targetPath} in container ${containerId}`);
-
-    // Use stat to get detailed file information
-    // Format: type|size|permissions|owner|group|mtime|atime|ctime
-    const result = await this.sandboxCommand.call({
-      containerId,
-      executable: 'stat',
-      args: ['-c', '%F|%s|%A|%U|%G|%y|%x|%w', targetPath],
-      workingDirectory: '/',
-      timeout: 10000,
-    });
-
-    if (!result.data) {
-      this.logger.error(`Failed to get file info for ${targetPath}: No result data`);
-      throw new Error(`Failed to get file info for ${targetPath}: No result data`);
-    }
-
-    if (result.data.exitCode !== 0) {
-      this.logger.error(`Failed to get file info for ${targetPath}: ${result.data.stderr || 'Unknown error'}`);
-      throw new Error(`Failed to get file info for ${targetPath}: ${result.data.stderr || 'Unknown error'}`);
-    }
-
-    const output = result.data.stdout.trim();
-    const parts = output.split('|');
-
-    if (parts.length < 8) {
-      this.logger.error(`Unexpected stat output format: ${output}`);
-      throw new Error(`Unexpected stat output format: ${output}`);
-    }
-
-    const [typeStr, sizeStr, permissions, owner, group, mtime, atime, ctime] = parts;
-
-    const name = targetPath.split('/').pop() || targetPath;
-    const fileType = this.parseFileType(typeStr);
-
-    this.logger.debug(`Retrieved info for ${targetPath}: type=${fileType}, size=${sizeStr}`);
-
-    return {
-      data: {
-        path: targetPath,
-        name,
-        type: fileType,
-        size: parseInt(sizeStr, 10),
-        permissions,
-        owner,
-        group,
-        modifiedAt: mtime,
-        accessedAt: atime,
-        createdAt: ctime === '-' ? mtime : ctime,
-      },
-    };
-  }
-
-  private parseFileType(typeStr: string): SandboxFileInfoResult['type'] {
-    const lower = typeStr.toLowerCase();
-    if (lower.includes('regular')) return 'file';
-    if (lower.includes('directory')) return 'directory';
-    if (lower.includes('symbolic link')) return 'symlink';
-    return 'other';
-  }
-}

package/src/tools/sandbox-list-directory.tool.ts

@@ -1,111 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { z } from 'zod';
-import { BaseTool, InjectTool, Tool, ToolResult } from '@loopstack/common';
-import { SandboxCommand } from '@loopstack/sandbox-tool';
-
-const inputSchema = z
-  .object({
-    containerId: z.string().describe('The ID of the container to list the directory from'),
-    path: z.string().describe('The path to the directory to list'),
-    recursive: z.boolean().default(false).describe('Whether to list directories recursively'),
-  })
-  .strict();
-
-type SandboxListDirectoryArgs = z.infer<typeof inputSchema>;
-
-interface FileEntry {
-  name: string;
-  type: 'file' | 'directory' | 'symlink' | 'other';
-  size: number;
-  path: string;
-}
-
-interface SandboxListDirectoryResult {
-  path: string;
-  entries: FileEntry[];
-}
-
-@Tool({
-  uiConfig: {
-    description: 'List files and directories in a sandbox container',
-  },
-  schema: inputSchema,
-})
-export class SandboxListDirectory extends BaseTool {
-  private readonly logger = new Logger(SandboxListDirectory.name);
-
-  @InjectTool() private sandboxCommand: SandboxCommand;
-
-  async call(args: SandboxListDirectoryArgs): Promise<ToolResult<SandboxListDirectoryResult>> {
-    const { containerId, path: dirPath, recursive } = args;
-
-    this.logger.debug(`Listing directory ${dirPath} in container ${containerId} (recursive: ${recursive})`);
-
-    // Use find for recursive, ls for non-recursive
-    // Output format: type size path
-    const command = recursive
-      ? `find '${dirPath.replace(/'/g, "'\\''")}' -printf '%y %s %p\\n'`
-      : `find '${dirPath.replace(/'/g, "'\\''")}' -maxdepth 1 -printf '%y %s %p\\n'`;
-
-    const result = await this.sandboxCommand.call({
-      containerId,
-      executable: 'sh',
-      args: ['-c', command],
-      workingDirectory: '/',
-      timeout: 30000,
-    });
-
-    if (!result.data) {
-      this.logger.error(`Failed to list directory ${dirPath}: No result data`);
-      throw new Error(`Failed to list directory ${dirPath}: No result data`);
-    }
-
-    if (result.data.exitCode !== 0) {
-      this.logger.error(`Failed to list directory ${dirPath}: ${result.data.stderr || 'Unknown error'}`);
-      throw new Error(`Failed to list directory ${dirPath}: ${result.data.stderr || 'Unknown error'}`);
-    }
-
-    const entries: FileEntry[] = [];
-    const lines = result.data.stdout.split('\n').filter((line) => line.trim());
-
-    for (const line of lines) {
-      const match = line.match(/^(\S)\s+(\d+)\s+(.+)$/);
-      if (match) {
-        const [, typeChar, sizeStr, fullPath] = match;
-        const name = fullPath.split('/').pop() || fullPath;
-
-        // Skip the directory itself in non-recursive mode
-        if (fullPath === dirPath) continue;
-
-        entries.push({
-          name,
-          type: this.parseFileType(typeChar),
-          size: parseInt(sizeStr, 10),
-          path: fullPath,
-        });
-      }
-    }
-
-    this.logger.debug(`Listed ${entries.length} entries in ${dirPath}`);
-
-    return {
-      data: {
-        path: dirPath,
-        entries,
-      },
-    };
-  }
-
-  private parseFileType(typeChar: string): FileEntry['type'] {
-    switch (typeChar) {
-      case 'f':
-        return 'file';
-      case 'd':
-        return 'directory';
-      case 'l':
-        return 'symlink';
-      default:
-        return 'other';
-    }
-  }
-}

package/src/tools/sandbox-read-file.tool.ts

@@ -1,65 +0,0 @@
-import { Logger } from '@nestjs/common';
-import { z } from 'zod';
-import { BaseTool, InjectTool, Tool, ToolResult } from '@loopstack/common';
-import { SandboxCommand } from '@loopstack/sandbox-tool';
-
-const inputSchema = z
-  .object({
-    containerId: z.string().describe('The ID of the container to read the file from'),
-    path: z.string().describe('The path to the file to read'),
-    encoding: z.enum(['utf8', 'base64']).default('utf8').describe('The encoding to use when reading the file'),
-  })
-  .strict();
-
-type SandboxReadFileArgs = z.infer<typeof inputSchema>;
-
-interface SandboxReadFileResult {
-  content: string;
-  encoding: string;
-}
-
-@Tool({
-  uiConfig: {
-    description: 'Read file contents from a sandbox container',
-  },
-  schema: inputSchema,
-})
-export class SandboxReadFile extends BaseTool {
-  private readonly logger = new Logger(SandboxReadFile.name);
-
-  @InjectTool() private sandboxCommand: SandboxCommand;
-
-  async call(args: SandboxReadFileArgs): Promise<ToolResult<SandboxReadFileResult>> {
-    const { containerId, path, encoding } = args;
-
-    this.logger.debug(`Reading file ${path} from container ${containerId} (encoding: ${encoding})`);
-
-    const executable = encoding === 'base64' ? 'base64' : 'cat';
-    const result = await this.sandboxCommand.call({
-      containerId,
-      executable,
-      args: [path],
-      workingDirectory: '/',
-      timeout: 30000,
-    });
-
-    if (!result.data) {
-      this.logger.error(`Failed to read file ${path}: No result data`);
-      throw new Error(`Failed to read file ${path}: No result data`);
-    }
-
-    if (result.data.exitCode !== 0) {
-      this.logger.error(`Failed to read file ${path}: ${result.data.stderr || 'Unknown error'}`);
-      throw new Error(`Failed to read file ${path}: ${result.data.stderr || 'Unknown error'}`);
-    }
-
-    this.logger.debug(`Successfully read file ${path} (${result.data.stdout.length} characters)`);
-
-    return {
-      data: {
-        content: result.data.stdout,
-        encoding,
-      },
-    };
-  }
-}

package/src/tools/sandbox-write-file.tool.ts

@@ -1,104 +0,0 @@
-import { Logger } from '@nestjs/common';
-import * as path from 'path';
-import { z } from 'zod';
-import { BaseTool, InjectTool, Tool, ToolResult } from '@loopstack/common';
-import { SandboxCommand } from '@loopstack/sandbox-tool';
-
-const inputSchema = z
-  .object({
-    containerId: z.string().describe('The ID of the container to write the file to'),
-    path: z.string().describe('The path where the file should be written'),
-    content: z.string().describe('The content to write to the file'),
-    encoding: z.enum(['utf8', 'base64']).default('utf8').describe('The encoding of the content'),
-    createParentDirs: z.boolean().default(true).describe("Whether to create parent directories if they don't exist"),
-  })
-  .strict();
-
-type SandboxWriteFileArgs = z.infer<typeof inputSchema>;
-
-interface SandboxWriteFileResult {
-  path: string;
-  bytesWritten: number;
-}
-
-@Tool({
-  uiConfig: {
-    description: 'Write content to a file in a sandbox container',
-  },
-  schema: inputSchema,
-})
-export class SandboxWriteFile extends BaseTool {
-  private readonly logger = new Logger(SandboxWriteFile.name);
-
-  @InjectTool() private sandboxCommand: SandboxCommand;
-
-  async call(args: SandboxWriteFileArgs): Promise<ToolResult<SandboxWriteFileResult>> {
-    const { containerId, path: filePath, content, encoding, createParentDirs } = args;
-
-    this.logger.debug(`Writing file ${filePath} to container ${containerId} (encoding: ${encoding})`);
-
-    // Create parent directories if needed
-    if (createParentDirs) {
-      const parentDir = path.posix.dirname(filePath);
-      if (parentDir !== '/' && parentDir !== '.') {
-        this.logger.debug(`Creating parent directory ${parentDir}`);
-        const mkdirResult = await this.sandboxCommand.call({
-          containerId,
-          executable: 'mkdir',
-          args: ['-p', parentDir],
-          workingDirectory: '/',
-          timeout: 5000,
-        });
-
-        if (!mkdirResult.data) {
-          this.logger.error(`Failed to create parent directory ${parentDir}: No result data`);
-          throw new Error(`Failed to create parent directory ${parentDir}: No result data`);
-        }
-
-        if (mkdirResult.data.exitCode !== 0) {
-          this.logger.error(
-            `Failed to create parent directory ${parentDir}: ${mkdirResult.data.stderr || 'Unknown error'}`,
-          );
-          throw new Error(
-            `Failed to create parent directory ${parentDir}: ${mkdirResult.data.stderr || 'Unknown error'}`,
-          );
-        }
-      }
-    }
-
-    // Encode content as base64 for safe transfer
-    const base64Content =
-      encoding === 'utf8' ? Buffer.from(content, 'utf8').toString('base64') : content.replace(/[^A-Za-z0-9+/=]/g, '');
-
-    // Write file using base64 decode
-    const result = await this.sandboxCommand.call({
-      containerId,
-      executable: 'sh',
-      args: ['-c', `echo '${base64Content}' | base64 -d > '${filePath.replace(/'/g, "'\\''")}'`],
-      workingDirectory: '/',
-      timeout: 30000,
-    });
-
-    if (!result.data) {
-      this.logger.error(`Failed to write file ${filePath}: No result data`);
-      throw new Error(`Failed to write file ${filePath}: No result data`);
-    }
-
-    if (result.data.exitCode !== 0) {
-      this.logger.error(`Failed to write file ${filePath}: ${result.data.stderr || 'Unknown error'}`);
-      throw new Error(`Failed to write file ${filePath}: ${result.data.stderr || 'Unknown error'}`);
-    }
-
-    const bytesWritten =
-      encoding === 'utf8' ? Buffer.from(content, 'utf8').length : Buffer.from(content, 'base64').length;
-
-    this.logger.log(`Successfully wrote ${bytesWritten} bytes to ${filePath} in container ${containerId}`);
-
-    return {
-      data: {
-        path: filePath,
-        bytesWritten,
-      },
-    };
-  }
-}