deepagents 1.7.1 → 1.7.3

package/dist/index.cjs

@@ -2021,7 +2021,8 @@ function parseSkillMetadataFromContent(content, skillPath, directoryName) {
 */
 async function listSkillsFromBackend(backend, sourcePath) {
 	const skills = [];
-	const normalizedPath = sourcePath.endsWith("/") || sourcePath.endsWith("\\") ? sourcePath : `${sourcePath}/`;
+	const pathSep = sourcePath.includes("\\") ? "\\" : "/";
+	const normalizedPath = sourcePath.endsWith("/") || sourcePath.endsWith("\\") ? sourcePath : `${sourcePath}${pathSep}`;
 	let fileInfos;
 	try {
 		fileInfos = await backend.lsInfo(normalizedPath);
@@ -2034,7 +2035,7 @@ async function listSkillsFromBackend(backend, sourcePath) {
 	}));
 	for (const entry of entries) {
 		if (entry.type !== "directory") continue;
-		const skillMdPath = `${normalizedPath}${entry.name}/SKILL.md`;
+		const skillMdPath = `${normalizedPath}${entry.name}${pathSep}SKILL.md`;
 		let content;
 		if (backend.downloadFiles) {
 			const results = await backend.downloadFiles([skillMdPath]);
@@ -3285,285 +3286,207 @@ var CompositeBackend = class {
 //#endregion
 //#region src/backends/sandbox.ts
 /**
-* Node.js command template for glob operations.
-* Uses web-standard atob() for base64 decoding.
+* Shell-quote a string using single quotes (POSIX).
+* Escapes embedded single quotes with the '\'' technique.
 */
-function buildGlobCommand(searchPath, pattern) {
-	return `node -e "
-const fs = require('fs');
-const path = require('path');
-
-const searchPath = atob('${btoa(searchPath)}');
-const pattern = atob('${btoa(pattern)}');
-
-function globMatch(relativePath, pattern) {
-  const regexPattern = pattern
-    .replace(/\\*\\*/g, '<<<GLOBSTAR>>>')
-    .replace(/\\*/g, '[^/]*')
-    .replace(/\\?/g, '.')
-    .replace(/<<<GLOBSTAR>>>/g, '.*');
-  return new RegExp('^' + regexPattern + '$').test(relativePath);
-}
-
-function walkDir(dir, baseDir, results) {
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      const relativePath = path.relative(baseDir, fullPath);
-      if (entry.isDirectory()) {
-        walkDir(fullPath, baseDir, results);
-      } else if (globMatch(relativePath, pattern)) {
-        const stat = fs.statSync(fullPath);
-        console.log(JSON.stringify({
-          path: relativePath,
-          size: stat.size,
-          mtime: stat.mtimeMs,
-          isDir: false
-        }));
-      }
-    }
-  } catch (e) {
-    // Silent failure for non-existent paths
-  }
-}
-
-try {
-  process.chdir(searchPath);
-  walkDir('.', '.', []);
-} catch (e) {
-  // Silent failure for non-existent paths
-}
-"`;
+function shellQuote(s) {
+	return "'" + s.replace(/'/g, "'\\''") + "'";
 }
 /**
-* Node.js command template for listing directory contents.
+* Convert a glob pattern to a path-aware RegExp.
+*
+* Inspired by the just-bash project's glob utilities:
+* - `*`  matches any characters except `/`
+* - `**` matches any characters including `/` (recursive)
+* - `?`  matches a single character except `/`
+* - `[...]` character classes
 */
-function buildLsCommand(dirPath) {
-	return `node -e "
-const fs = require('fs');
-const path = require('path');
-
-const dirPath = atob('${btoa(dirPath)}');
-
-try {
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry.name);
-    const stat = fs.statSync(fullPath);
-    console.log(JSON.stringify({
-      path: entry.isDirectory() ? fullPath + '/' : fullPath,
-      size: stat.size,
-      mtime: stat.mtimeMs,
-      isDir: entry.isDirectory()
-    }));
-  }
-} catch (e) {
-  console.error('Error: ' + e.message);
-  process.exit(1);
-}
-"`;
+function globToPathRegex(pattern) {
+	let regex = "^";
+	let i = 0;
+	while (i < pattern.length) {
+		const c = pattern[i];
+		if (c === "*") if (i + 1 < pattern.length && pattern[i + 1] === "*") {
+			i += 2;
+			if (i < pattern.length && pattern[i] === "/") {
+				regex += "(.*/)?";
+				i++;
+			} else regex += ".*";
+		} else {
+			regex += "[^/]*";
+			i++;
+		}
+		else if (c === "?") {
+			regex += "[^/]";
+			i++;
+		} else if (c === "[") {
+			let j = i + 1;
+			while (j < pattern.length && pattern[j] !== "]") j++;
+			regex += pattern.slice(i, j + 1);
+			i = j + 1;
+		} else if (c === "." || c === "+" || c === "^" || c === "$" || c === "{" || c === "}" || c === "(" || c === ")" || c === "|" || c === "\\") {
+			regex += `\\${c}`;
+			i++;
+		} else {
+			regex += c;
+			i++;
+		}
+	}
+	regex += "$";
+	return new RegExp(regex);
 }
 /**
-* Node.js command template for reading files.
+* Parse a single line of stat/find output in the format: size\tmtime\ttype\tpath
+*
+* The first three tab-delimited fields are always fixed (number, number, string),
+* so we safely take everything after the third tab as the file path — even if the
+* path itself contains tabs.
+*
+* The type field varies by platform / tool:
+* - GNU find -printf %y: single letter "d", "f", "l"
+* - BSD stat -f %Sp: permission strings like "drwxr-xr-x", "-rw-r--r--"
+*
+* The mtime field may be a float (GNU find %T@ → "1234567890.0000000000")
+* or an integer (BSD stat %m → "1234567890"); parseInt handles both.
 */
-function buildReadCommand(filePath, offset, limit) {
-	return `node -e "
-const fs = require('fs');
-
-const filePath = atob('${btoa(filePath)}');
-const offset = ${Number.isFinite(offset) && offset > 0 ? Math.floor(offset) : 0};
-const limit = ${Number.isFinite(limit) && limit > 0 && limit < Number.MAX_SAFE_INTEGER ? Math.floor(limit) : 0};
-
-if (!fs.existsSync(filePath)) {
-  console.log('Error: File not found');
-  process.exit(1);
-}
-
-const stat = fs.statSync(filePath);
-if (stat.size === 0) {
-  console.log('System reminder: File exists but has empty contents');
-  process.exit(0);
-}
-
-const content = fs.readFileSync(filePath, 'utf-8');
-const lines = content.split('\\n');
-const selected = lines.slice(offset, offset + limit);
-
-for (let i = 0; i < selected.length; i++) {
-  const lineNum = offset + i + 1;
-  console.log(String(lineNum).padStart(6) + '\\t' + selected[i]);
-}
-"`;
+function parseStatLine(line) {
+	const firstTab = line.indexOf("	");
+	if (firstTab === -1) return null;
+	const secondTab = line.indexOf("	", firstTab + 1);
+	if (secondTab === -1) return null;
+	const thirdTab = line.indexOf("	", secondTab + 1);
+	if (thirdTab === -1) return null;
+	const size = parseInt(line.slice(0, firstTab), 10);
+	const mtime = parseInt(line.slice(firstTab + 1, secondTab), 10);
+	const fileType = line.slice(secondTab + 1, thirdTab);
+	const fullPath = line.slice(thirdTab + 1);
+	if (isNaN(size) || isNaN(mtime)) return null;
+	return {
+		size,
+		mtime,
+		isDir: fileType === "d" || fileType === "directory" || fileType.startsWith("d"),
+		fullPath
+	};
 }
 /**
-* Node.js command template for writing files.
+* BusyBox/Alpine fallback script for stat -c.
+*
+* Determines file type with POSIX test builtins, then uses stat -c
+* (supported by both GNU coreutils and BusyBox) for size and mtime.
+* printf handles tab-delimited output formatting.
 */
-function buildWriteCommand(filePath, content) {
-	return `node -e "
-const fs = require('fs');
-const path = require('path');
-
-const filePath = atob('${btoa(filePath)}');
-const content = atob('${btoa(content)}');
-
-if (fs.existsSync(filePath)) {
-  console.error('Error: File already exists');
-  process.exit(1);
-}
-
-const parentDir = path.dirname(filePath) || '.';
-fs.mkdirSync(parentDir, { recursive: true });
-
-fs.writeFileSync(filePath, content, 'utf-8');
-console.log('OK');
-"`;
-}
+const STAT_C_SCRIPT = "for f; do if [ -d \"$f\" ]; then t=d; elif [ -L \"$f\" ]; then t=l; else t=f; fi; sz=$(stat -c %s \"$f\" 2>/dev/null) || continue; mt=$(stat -c %Y \"$f\" 2>/dev/null) || continue; printf \"%s\\t%s\\t%s\\t%s\\n\" \"$sz\" \"$mt\" \"$t\" \"$f\"; done";
 /**
-* Node.js command template for editing files.
+* Shell command for listing directory contents with metadata.
+*
+* Detects the environment at runtime with three-way probing:
+* 1. GNU find (full Linux): uses built-in `-printf` (most efficient)
+* 2. BusyBox / Alpine: uses `find -exec sh -c` with `stat -c` fallback
+* 3. BSD / macOS: uses `find -exec stat -f`
+*
+* Output format per line: size\tmtime\ttype\tpath
 */
-function buildEditCommand(filePath, oldStr, newStr, replaceAll) {
-	return `node -e "
-const fs = require('fs');
-
-const filePath = atob('${btoa(filePath)}');
-const oldStr = atob('${btoa(oldStr)}');
-const newStr = atob('${btoa(newStr)}');
-const replaceAll = ${Boolean(replaceAll)};
-
-let text;
-try {
-  text = fs.readFileSync(filePath, 'utf-8');
-} catch (e) {
-  process.exit(3);
-}
-
-const count = text.split(oldStr).length - 1;
-
-if (count === 0) {
-  process.exit(1);
+function buildLsCommand(dirPath) {
+	const quotedPath = shellQuote(dirPath);
+	const findBase = `find ${quotedPath} -maxdepth 1 -not -path ${quotedPath}`;
+	return `if find /dev/null -maxdepth 0 -printf '' 2>/dev/null; then ${findBase} -printf '%s\\t%T@\\t%y\\t%p\\n' 2>/dev/null; elif stat -c %s /dev/null >/dev/null 2>&1; then ${findBase} -exec sh -c '${STAT_C_SCRIPT}' _ {} +; else ${findBase} -exec stat -f '%z\t%m\t%Sp\t%N' {} + 2>/dev/null; fi || true`;
 }
-if (count > 1 && !replaceAll) {
-  process.exit(2);
+/**
+* Shell command for listing files recursively with metadata.
+* Same three-way detection as buildLsCommand (GNU -printf / stat -c / BSD stat -f).
+*
+* Output format per line: size\tmtime\ttype\tpath
+*/
+function buildFindCommand(searchPath) {
+	const quotedPath = shellQuote(searchPath);
+	const findBase = `find ${quotedPath} -not -path ${quotedPath}`;
+	return `if find /dev/null -maxdepth 0 -printf '' 2>/dev/null; then ${findBase} -printf '%s\\t%T@\\t%y\\t%p\\n' 2>/dev/null; elif stat -c %s /dev/null >/dev/null 2>&1; then ${findBase} -exec sh -c '${STAT_C_SCRIPT}' _ {} +; else ${findBase} -exec stat -f '%z\t%m\t%Sp\t%N' {} + 2>/dev/null; fi || true`;
 }
-
-const result = text.split(oldStr).join(newStr);
-fs.writeFileSync(filePath, result, 'utf-8');
-console.log(count);
-"`;
+/**
+* Pure POSIX shell command for reading files with line numbers.
+* Uses awk for line numbering with offset/limit — works on any Linux including Alpine.
+*/
+function buildReadCommand(filePath, offset, limit) {
+	const quotedPath = shellQuote(filePath);
+	const safeOffset = Number.isFinite(offset) && offset > 0 ? Math.floor(offset) : 0;
+	const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.min(Math.floor(limit), 999999999) : 999999999;
+	const start = safeOffset + 1;
+	const end = safeOffset + safeLimit;
+	return [
+		`if [ ! -f ${quotedPath} ]; then echo "Error: File not found"; exit 1; fi`,
+		`if [ ! -s ${quotedPath} ]; then echo "System reminder: File exists but has empty contents"; exit 0; fi`,
+		`awk 'NR >= ${start} && NR <= ${end} { printf "%6d\\t%s\\n", NR, $0 }' ${quotedPath}`
+	].join("; ");
 }
 /**
-* Node.js command template for grep operations with literal (fixed-string) search.
+* Build a grep command for literal (fixed-string) search.
+* Uses grep -rHnF for recursive, with-filename, with-line-number, fixed-string search.
+*
+* When a glob pattern is provided, uses `find -name GLOB -exec grep` instead of
+* `grep --include=GLOB` for universal compatibility (BusyBox grep lacks --include).
 *
 * @param pattern - Literal string to search for (NOT regex).
 * @param searchPath - Base path to search in.
 * @param globPattern - Optional glob pattern to filter files.
 */
 function buildGrepCommand(pattern, searchPath, globPattern) {
-	const patternB64 = btoa(pattern);
-	const pathB64 = btoa(searchPath);
-	const globB64 = globPattern ? btoa(globPattern) : "";
-	return `node -e "
-const fs = require('fs');
-const path = require('path');
-
-const pattern = atob('${patternB64}');
-const searchPath = atob('${pathB64}');
-const globPattern = ${globPattern ? `atob('${globB64}')` : "null"};
-
-function globMatch(filePath, pattern) {
-  if (!pattern) return true;
-  const regexPattern = pattern
-    .replace(/\\*\\*/g, '<<<GLOBSTAR>>>')
-    .replace(/\\*/g, '[^/]*')
-    .replace(/\\?/g, '.')
-    .replace(/<<<GLOBSTAR>>>/g, '.*');
-  return new RegExp('^' + regexPattern + '$').test(filePath);
-}
-
-function walkDir(dir, results) {
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walkDir(fullPath, results);
-      } else {
-        const relativePath = path.relative(searchPath, fullPath);
-        if (globMatch(relativePath, globPattern)) {
-          try {
-            const content = fs.readFileSync(fullPath, 'utf-8');
-            const lines = content.split('\\n');
-            for (let i = 0; i < lines.length; i++) {
-              // Simple substring search for literal matching
-              if (lines[i].includes(pattern)) {
-                console.log(JSON.stringify({
-                  path: fullPath,
-                  line: i + 1,
-                  text: lines[i]
-                }));
-              }
-            }
-          } catch (e) {
-            // Skip unreadable files
-          }
-        }
-      }
-    }
-  } catch (e) {
-    // Skip unreadable directories
-  }
-}
-
-try {
-  walkDir(searchPath, []);
-} catch (e) {
-  // Silent failure
-}
-"`;
+	const patternEscaped = shellQuote(pattern);
+	const searchPathQuoted = shellQuote(searchPath);
+	if (globPattern) return `find ${searchPathQuoted} -type f -name ${shellQuote(globPattern)} -exec grep -HnF -e ${patternEscaped} {} + 2>/dev/null || true`;
+	return `grep -rHnF -e ${patternEscaped} ${searchPathQuoted} 2>/dev/null || true`;
 }
 /**
 * Base sandbox implementation with execute() as the only abstract method.
 *
 * This class provides default implementations for all SandboxBackendProtocol
 * methods using shell commands executed via execute(). Concrete implementations
-* only need to implement the execute() method.
+* only need to implement execute(), uploadFiles(), and downloadFiles().
 *
-* Requires Node.js 20+ on the sandbox host.
+* All shell commands use pure POSIX utilities (awk, grep, find, stat) that are
+* available on any Linux including Alpine/busybox. No Python, Node.js, or
+* other runtime is required on the sandbox host.
 */
 var BaseSandbox = class {
 	/**
 	* List files and directories in the specified directory (non-recursive).
 	*
+	* Uses pure POSIX shell (find + stat) via execute() — works on any Linux
+	* including Alpine. No Python or Node.js needed.
+	*
 	* @param path - Absolute path to directory
 	* @returns List of FileInfo objects for files and directories directly in the directory.
 	*/
 	async lsInfo(path) {
 		const command = buildLsCommand(path);
 		const result = await this.execute(command);
-		if (result.exitCode !== 0) return [];
 		const infos = [];
 		const lines = result.output.trim().split("\n").filter(Boolean);
-		for (const line of lines) try {
-			const parsed = JSON.parse(line);
+		for (const line of lines) {
+			const parsed = parseStatLine(line);
+			if (!parsed) continue;
 			infos.push({
-				path: parsed.path,
+				path: parsed.isDir ? parsed.fullPath + "/" : parsed.fullPath,
 				is_dir: parsed.isDir,
 				size: parsed.size,
-				modified_at: parsed.mtime ? new Date(parsed.mtime).toISOString() : void 0
+				modified_at: (/* @__PURE__ */ new Date(parsed.mtime * 1e3)).toISOString()
 			});
-		} catch {}
+		}
 		return infos;
 	}
 	/**
 	* Read file content with line numbers.
 	*
+	* Uses pure POSIX shell (awk) via execute() — only the requested slice
+	* is returned over the wire, making this efficient for large files.
+	* Works on any Linux including Alpine (no Python or Node.js needed).
+	*
 	* @param filePath - Absolute file path
 	* @param offset - Line offset to start reading from (0-indexed)
 	* @param limit - Maximum number of lines to read
 	* @returns Formatted file content with line numbers, or error message
 	*/
 	async read(filePath, offset = 0, limit = 500) {
+		if (limit === 0) return "";
 		const command = buildReadCommand(filePath, offset, limit);
 		const result = await this.execute(command);
 		if (result.exitCode !== 0) return `Error: File '${filePath}' not found`;
@@ -3572,18 +3495,15 @@ var BaseSandbox = class {
 	/**
 	* Read file content as raw FileData.
 	*
+	* Uses downloadFiles() directly — no runtime needed on the sandbox host.
+	*
 	* @param filePath - Absolute file path
 	* @returns Raw file content as FileData
 	*/
 	async readRaw(filePath) {
-		const command = buildReadCommand(filePath, 0, Number.MAX_SAFE_INTEGER);
-		const result = await this.execute(command);
-		if (result.exitCode !== 0) throw new Error(`File '${filePath}' not found`);
-		const lines = [];
-		for (const line of result.output.split("\n")) {
-			const tabIndex = line.indexOf("	");
-			if (tabIndex !== -1) lines.push(line.substring(tabIndex + 1));
-		}
+		const results = await this.downloadFiles([filePath]);
+		if (results[0].error || !results[0].content) throw new Error(`File '${filePath}' not found`);
+		const lines = new TextDecoder().decode(results[0].content).split("\n");
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		return {
 			content: lines,
@@ -3592,7 +3512,7 @@ var BaseSandbox = class {
 		};
 	}
 	/**
-	* Search for a literal text pattern in files.
+	* Search for a literal text pattern in files using grep.
 	*
 	* @param pattern - Literal string to search for (NOT regex).
 	* @param path - Directory or file path to search in.
@@ -3601,44 +3521,69 @@ var BaseSandbox = class {
 	*/
 	async grepRaw(pattern, path = "/", glob = null) {
 		const command = buildGrepCommand(pattern, path, glob);
-		const result = await this.execute(command);
+		const output = (await this.execute(command)).output.trim();
+		if (!output) return [];
 		const matches = [];
-		const lines = result.output.trim().split("\n").filter(Boolean);
-		for (const line of lines) try {
-			const parsed = JSON.parse(line);
-			matches.push({
-				path: parsed.path,
-				line: parsed.line,
-				text: parsed.text
-			});
-		} catch {}
+		for (const line of output.split("\n")) {
+			const parts = line.split(":");
+			if (parts.length >= 3) {
+				const lineNum = parseInt(parts[1], 10);
+				if (!isNaN(lineNum)) matches.push({
+					path: parts[0],
+					line: lineNum,
+					text: parts.slice(2).join(":")
+				});
+			}
+		}
 		return matches;
 	}
 	/**
 	* Structured glob matching returning FileInfo objects.
+	*
+	* Uses pure POSIX shell (find + stat) via execute() to list all files,
+	* then applies glob-to-regex matching in TypeScript. No Python or Node.js
+	* needed on the sandbox host.
+	*
+	* Glob patterns are matched against paths relative to the search base:
+	* - `*`  matches any characters except `/`
+	* - `**` matches any characters including `/` (recursive)
+	* - `?`  matches a single character except `/`
+	* - `[...]` character classes
 	*/
 	async globInfo(pattern, path = "/") {
-		const command = buildGlobCommand(path, pattern);
+		const command = buildFindCommand(path);
 		const result = await this.execute(command);
+		const regex = globToPathRegex(pattern);
 		const infos = [];
 		const lines = result.output.trim().split("\n").filter(Boolean);
-		for (const line of lines) try {
-			const parsed = JSON.parse(line);
-			infos.push({
-				path: parsed.path,
+		const basePath = path.endsWith("/") ? path.slice(0, -1) : path;
+		for (const line of lines) {
+			const parsed = parseStatLine(line);
+			if (!parsed) continue;
+			const relPath = parsed.fullPath.startsWith(basePath + "/") ? parsed.fullPath.slice(basePath.length + 1) : parsed.fullPath;
+			if (regex.test(relPath)) infos.push({
+				path: relPath,
 				is_dir: parsed.isDir,
 				size: parsed.size,
-				modified_at: parsed.mtime ? new Date(parsed.mtime).toISOString() : void 0
+				modified_at: (/* @__PURE__ */ new Date(parsed.mtime * 1e3)).toISOString()
 			});
-		} catch {}
+		}
 		return infos;
 	}
 	/**
 	* Create a new file with content.
+	*
+	* Uses downloadFiles() to check existence and uploadFiles() to write.
+	* No runtime needed on the sandbox host.
 	*/
 	async write(filePath, content) {
-		const command = buildWriteCommand(filePath, content);
-		if ((await this.execute(command)).exitCode !== 0) return { error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.` };
+		try {
+			const existCheck = await this.downloadFiles([filePath]);
+			if (existCheck[0].content !== null && existCheck[0].error === null) return { error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.` };
+		} catch {}
+		const encoder = new TextEncoder();
+		const results = await this.uploadFiles([[filePath, encoder.encode(content)]]);
+		if (results[0].error) return { error: `Failed to write to ${filePath}: ${results[0].error}` };
 		return {
 			path: filePath,
 			filesUpdate: null
@@ -3646,21 +3591,26 @@ var BaseSandbox = class {
 	}
 	/**
 	* Edit a file by replacing string occurrences.
+	*
+	* Uses downloadFiles() to read, performs string replacement in TypeScript,
+	* then uploadFiles() to write back. No runtime needed on the sandbox host.
 	*/
 	async edit(filePath, oldString, newString, replaceAll = false) {
-		const command = buildEditCommand(filePath, oldString, newString, replaceAll);
-		const result = await this.execute(command);
-		switch (result.exitCode) {
-			case 0: return {
-				path: filePath,
-				filesUpdate: null,
-				occurrences: parseInt(result.output.trim(), 10) || 1
-			};
-			case 1: return { error: `String not found in file '${filePath}'` };
-			case 2: return { error: `Multiple occurrences found in '${filePath}'. Use replaceAll=true to replace all.` };
-			case 3: return { error: `Error: File '${filePath}' not found` };
-			default: return { error: `Unknown error editing file '${filePath}'` };
-		}
+		const results = await this.downloadFiles([filePath]);
+		if (results[0].error || !results[0].content) return { error: `Error: File '${filePath}' not found` };
+		const text = new TextDecoder().decode(results[0].content);
+		const count = text.split(oldString).length - 1;
+		if (count === 0) return { error: `String not found in file '${filePath}'` };
+		if (count > 1 && !replaceAll) return { error: `Multiple occurrences found in '${filePath}'. Use replaceAll=true to replace all.` };
+		const newText = replaceAll ? text.split(oldString).join(newString) : text.replace(oldString, newString);
+		const encoder = new TextEncoder();
+		const uploadResults = await this.uploadFiles([[filePath, encoder.encode(newText)]]);
+		if (uploadResults[0].error) return { error: `Failed to write edited file '${filePath}': ${uploadResults[0].error}` };
+		return {
+			path: filePath,
+			filesUpdate: null,
+			occurrences: count
+		};
 	}
 };