switch sdk fs to use promises only

Author: charleslien

common/src/project-file-tree.ts

@@ -11,11 +11,11 @@ import type { DirectoryNode, FileTreeNode } from './util/file'
 
 export const DEFAULT_MAX_FILES = 10_000
 
-export function getProjectFileTree(params: {
+export async function getProjectFileTree(params: {
   projectRoot: string
   maxFiles?: number
   fs: CodebuffFileSystem
-}): FileTreeNode[] {
+}): Promise<FileTreeNode[]> {
   const withDefaults = { maxFiles: DEFAULT_MAX_FILES, ...params }
   const { projectRoot, fs } = withDefaults
   let { maxFiles } = withDefaults
@@ -55,10 +55,10 @@ export function getProjectFileTree(params: {
     const mergedIgnore = ignore
       .default()
       .add(currentIgnore)
-      .add(parseGitignore({ fullDirPath: fullPath, projectRoot, fs }))
+      .add(await parseGitignore({ fullDirPath: fullPath, projectRoot, fs }))
 
     try {
-      const files = fs.readdirSync(fullPath)
+      const files = await fs.readdir(fullPath)
       for (const file of files) {
         if (totalFiles >= maxFiles) break
 
@@ -68,7 +68,7 @@ export function getProjectFileTree(params: {
         if (mergedIgnore.ignores(relativeFilePath)) continue
 
         try {
-          const stats = fs.statSync(filePath)
+          const stats = await fs.stat(filePath)
           if (stats.isDirectory()) {
             const childNode: DirectoryNode = {
               name: file,
@@ -151,11 +151,11 @@ function rebaseGitignorePattern(
   return isNegated ? `!${rebased}` : rebased
 }
 
-export function parseGitignore(params: {
+export async function parseGitignore(params: {
   fullDirPath: string
   projectRoot: string
   fs: CodebuffFileSystem
-}): ignore.Ignore {
+}): Promise<ignore.Ignore> {
   const { fullDirPath, projectRoot, fs } = params
 
   const ig = ignore.default()
@@ -167,9 +167,9 @@ export function parseGitignore(params: {
   ]
 
   for (const ignoreFilePath of ignoreFiles) {
-    if (!fs.existsSync(ignoreFilePath)) continue
+    if (!(await fs.exists(ignoreFilePath))) continue
 
-    const ignoreContent = fs.readFileSync(ignoreFilePath, 'utf8')
+    const ignoreContent = await fs.readFile(ignoreFilePath, 'utf8')
     const lines = ignoreContent.split('\n')
     for (let line of lines) {
       line = line.trim()
@@ -218,11 +218,11 @@ export function getLastReadFilePaths(
     .map((node) => node.filePath)
 }
 
-export function isFileIgnored(params: {
+export async function isFileIgnored(params: {
   filePath: string
   projectRoot: string
   fs: CodebuffFileSystem
-}): boolean {
+}): Promise<boolean> {
   const { filePath, projectRoot, fs } = params
 
   const defaultIgnore = ignore.default()
@@ -241,7 +241,7 @@ export function isFileIgnored(params: {
   let currentDir = dirPath
   while (currentDir.startsWith(projectRoot)) {
     mergedIgnore.add(
-      parseGitignore({ fullDirPath: currentDir, projectRoot, fs }),
+      await parseGitignore({ fullDirPath: currentDir, projectRoot, fs }),
     )
     currentDir = path.dirname(currentDir)
   }

common/src/types/filesystem.ts

@@ -2,14 +2,9 @@ import type fs from 'fs'
 
 /** File system used for Codebuff SDK.
  *
- * Compatible with the `'fs'` module
+ * Compatible with `fs.promises` from the `'fs'` module.
  */
 export type CodebuffFileSystem = Pick<
-  typeof fs,
-  | 'existsSync'
-  | 'mkdirSync'
-  | 'readdirSync'
-  | 'readFileSync'
-  | 'statSync'
-  | 'writeFileSync'
-> & { promises: Pick<typeof fs.promises, 'readdir'> }
+  typeof fs.promises,
+  'exists' | 'mkdir' | 'readdir' | 'readFile' | 'stat' | 'writeFile'
+>

common/src/types/util.ts

@@ -0,0 +1,3 @@
+export type Prettify<T> = {
+  [K in keyof T]: T[K]
+} & {}

common/src/util/file.ts

@@ -215,14 +215,14 @@ export const ensureEndsWithNewline = (
   return contents + '\n'
 }
 
-export const ensureDirectoryExists = (params: {
+export const ensureDirectoryExists = async (params: {
   baseDir: string
   fs: CodebuffFileSystem
 }) => {
   const { baseDir, fs } = params
 
-  if (!fs.existsSync(baseDir)) {
-    fs.mkdirSync(baseDir, { recursive: true })
+  if (!(await fs.exists(baseDir))) {
+    await fs.mkdir(baseDir, { recursive: true })
   }
 }
 
@@ -249,14 +249,14 @@ export function isValidFilePath(path: string) {
   return true
 }
 
-export function isDir(params: {
+export async function isDir(params: {
   path: string
   fs: CodebuffFileSystem
-}): boolean {
+}): Promise<boolean> {
   const { path, fs } = params
 
   try {
-    return fs.statSync(path).isDirectory()
+    return (await fs.stat(path)).isDirectory()
   } catch {
     return false
   }

common/src/util/git.ts

@@ -137,7 +137,10 @@ export async function createFileReadingMock(projectRoot: string) {
 export async function getProjectFileContext(
   projectPath: string,
 ): Promise<ProjectFileContext> {
-  const fileTree = getProjectFileTree({ projectRoot: projectPath, fs })
+  const fileTree = await getProjectFileTree({
+    projectRoot: projectPath,
+    fs: fs.promises,
+  })
   const allFilePaths = getAllFilePaths(fileTree)
   const knowledgeFilePaths = allFilePaths.filter((filePath) =>
     filePath.endsWith('knowledge.md'),

evals/scaffolding.ts

@@ -1,13 +1,8 @@
-import * as fs from 'fs'
-import * as path from 'path'
-
 import { BROWSER_DEFAULTS } from '@codebuff/common/browser-actions'
-import { ensureDirectoryExists } from '@codebuff/common/util/file'
 import { sleep } from '@codebuff/common/util/promise'
 import { ensureUrlProtocol } from '@codebuff/common/util/string'
 import puppeteer from 'puppeteer-core'
 
-import { getCurrentChatDir } from './project-files'
 import { logger } from './utils/logger'
 
 import type {
@@ -466,94 +461,6 @@ export class BrowserRunner {
     }
   }
 
-  private async takeScreenshot(
-    action: Extract<BrowserAction, { type: 'screenshot' }>,
-    page: Page,
-  ): Promise<{
-    data: string
-    logs: BrowserResponse['logs']
-  }> {
-    // Take a screenshot with aggressive compression settings
-    const screenshot = await page.screenshot({
-      fullPage: BROWSER_DEFAULTS.fullPage,
-      type: 'jpeg',
-      quality:
-        action.screenshotCompressionQuality ??
-        BROWSER_DEFAULTS.screenshotCompressionQuality,
-      encoding: 'base64',
-    })
-
-    // Log screenshot capture and size
-    const sizeInKB = Math.round((screenshot.length * 3) / 4 / 1024)
-    this.logs.push({
-      type: 'info',
-      message: `Captured screenshot (${sizeInKB}KB)`,
-      timestamp: Date.now(),
-      category: 'screenshot',
-      source: 'tool',
-    })
-
-    // If debug mode is enabled, save the screenshot
-    if (action.debug) {
-      console.debug({
-        message: 'Saving screenshot to disk...',
-        timestamp: Date.now(),
-        source: 'tool',
-      })
-
-      try {
-        const chatDir = getCurrentChatDir()
-        const screenshotsDir = path.join(chatDir, 'screenshots')
-        ensureDirectoryExists({ baseDir: screenshotsDir, fs })
-
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-        const filename = `screenshot-${timestamp}.jpg`
-        const filepath = path.join(screenshotsDir, filename)
-
-        fs.writeFileSync(filepath, Buffer.from(screenshot, 'base64'))
-        console.debug({
-          type: 'debug',
-          message: `Saved screenshot to ${filepath}`,
-          timestamp: Date.now(),
-          source: 'tool',
-        })
-
-        // Save metadata
-        const metadataPath = path.join(
-          screenshotsDir,
-          `${timestamp}-metadata.json`,
-        )
-        const metadata = {
-          timestamp,
-          format: 'jpeg',
-          quality: 25,
-          fullPage: action.fullPage ?? BROWSER_DEFAULTS.fullPage,
-          metrics: await this.collectMetrics(),
-        }
-        fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2))
-      } catch (error) {
-        console.error({
-          message: `Failed to save screenshot: ${(error as Error).message}`,
-          timestamp: Date.now(),
-          source: 'tool',
-        })
-        logger.error(
-          {
-            errorMessage:
-              error instanceof Error ? error.message : String(error),
-            errorStack: error instanceof Error ? error.stack : undefined,
-          },
-          'Failed to save screenshot',
-        )
-      }
-    }
-
-    return {
-      data: screenshot,
-      logs: this.logs,
-    }
-  }
-
   private attachPageListeners() {
     if (!this.page) return
 

npm-app/src/browser-runner.ts

@@ -3,13 +3,13 @@ import * as path from 'path'
 
 import { transformJsonInString } from '@codebuff/common/util/string'
 
-import { getCurrentChatDir, getCurrentChatId } from './project-files'
+import { getCurrentChatDirSync, getCurrentChatId } from './project-files'
 import { logger } from './utils/logger'
 
 import type { Log } from '@codebuff/common/browser-actions'
 import type { Message } from '@codebuff/common/types/messages/codebuff-message'
 
-export function setMessages(messages: Message[]) {
+export function setMessagesSync(messages: Message[]) {
   // Clean up any screenshots and logs in previous messages
   // Skip the last message as it may not have been processed by the backend yet
   const lastIndex = messages.length - 1
@@ -76,7 +76,7 @@ export function setMessages(messages: Message[]) {
 
   // Save messages to chat directory
   try {
-    const chatDir = getCurrentChatDir()
+    const chatDir = getCurrentChatDirSync()
     const messagesPath = path.join(chatDir, 'messages.json')
 
     const messagesData = {

npm-app/src/chat-storage.ts

@@ -10,7 +10,6 @@ import {
   getAllAgents,
   getAgentDisplayName,
 } from '@codebuff/common/util/agent-name-resolver'
-import { isDir } from '@codebuff/common/util/file'
 import { pluralize } from '@codebuff/common/util/string'
 import { uniq } from 'lodash'
 import {
@@ -601,17 +600,21 @@ export class CLI {
     const partial = input.endsWith(directorySuffix) ? '' : basename(input)
 
     let baseDir = isAbsolute(dir) ? dir : path.join(getWorkingDirectory(), dir)
+    function isDirSync(path: string): boolean {
+      try {
+        return fs.statSync(path).isDirectory()
+      } catch {
+        return false
+      }
+    }
 
     try {
       const files = readdirSync(baseDir)
       const fsMatches = files
         .filter((file) => file.startsWith(partial))
         .map(
           (file) =>
-            file +
-            (isDir({ path: path.join(baseDir, file), fs })
-              ? directorySuffix
-              : ''),
+            file + (isDirSync(path.join(baseDir, file)) ? directorySuffix : ''),
         )
       return [fsMatches, partial]
     } catch {