[Bug] - Incorrectly handled absolute paths

.changeset/gentle-spiders-know.md

@@ -0,0 +1,6 @@
+---
+'@e2b/python-sdk': patch
+'e2b': patch
+---
+
+added handling for absolute file paths (/) and up paths (../)

packages/js-sdk/package.json

@@ -63,6 +63,7 @@
     "openapi-typescript": "^7.9.1",
     "playwright": "^1.55.1",
     "react": "^18.3.1",
+    "tar": "^7.5.2",
     "tsup": "^8.4.0",
     "typedoc": "0.26.8",
     "typedoc-plugin-markdown": "4.2.7",
@@ -97,9 +98,9 @@
     "compare-versions": "^6.1.0",
     "dockerfile-ast": "^0.7.1",
     "glob": "^11.1.0",
+    "modern-tar": "^0.7.3",
     "openapi-fetch": "^0.14.1",
-    "platform": "^1.3.6",
-    "tar": "^7.5.2"
+    "platform": "^1.3.6"
   },
   "engines": {
     "node": ">=20"

packages/js-sdk/src/template/buildApi.ts

@@ -88,19 +88,19 @@ export async function getFileUploadLink(
 
 export async function uploadFile(
   options: {
-    fileName: string
+    filePath: string
     fileContextPath: string
     url: string
     ignorePatterns: string[]
     resolveSymlinks: boolean
   },
   stackTrace: string | undefined
 ) {
-  const { fileName, url, fileContextPath, ignorePatterns, resolveSymlinks } =
+  const { filePath, url, fileContextPath, ignorePatterns, resolveSymlinks } =
     options
   try {
     const { contentLength, uploadStream } = await tarFileStreamUpload(
-      fileName,
+      filePath,
       fileContextPath,
       ignorePatterns,
       resolveSymlinks

packages/js-sdk/src/template/index.ts

@@ -39,6 +39,7 @@ import {
   padOctal,
   readDockerignore,
   readGCPServiceAccountJSON,
+  rewriteSrc,
 } from './utils'
 
 /**
@@ -358,7 +359,7 @@ export class TemplateBase
 
     for (const src of srcs) {
       const args = [
-        src.toString(),
+        rewriteSrc(src.toString(), this.fileContextPath.toString()),
         dest.toString(),
         options?.user ?? '',
         options?.mode ? padOctal(options.mode) : '',
@@ -370,6 +371,7 @@ export class TemplateBase
         force: options?.forceUpload || this.forceNextLayer,
         forceUpload: options?.forceUpload,
         resolveSymlinks: options?.resolveSymlinks,
+        filePath: src.toString(),
       })
     }
 
@@ -896,8 +898,9 @@ export class TemplateBase
         }
 
         const src = instruction.args.length > 0 ? instruction.args[0] : null
+        const filePath = instruction.filePath ?? null
         const filesHash = instruction.filesHash ?? null
-        if (src === null || filesHash === null) {
+        if (src === null || filePath === null || filesHash === null) {
           throw new Error('Source path and files hash are required')
         }
 
@@ -922,7 +925,7 @@ export class TemplateBase
         ) {
           await uploadFile(
             {
-              fileName: src,
+              filePath,
               fileContextPath: this.fileContextPath.toString(),
               url,
               ignorePatterns: [
@@ -984,9 +987,9 @@ export class TemplateBase
           return instruction
         }
 
-        const src = instruction.args.length > 0 ? instruction.args[0] : null
+        const filePath = instruction.filePath ?? null
         const dest = instruction.args.length > 1 ? instruction.args[1] : null
-        if (src === null || dest === null) {
+        if (filePath === null || dest === null) {
           throw new Error('Source path and destination path are required')
         }
 
@@ -998,7 +1001,7 @@ export class TemplateBase
         return {
           ...instruction,
           filesHash: await calculateFilesHash(
-            src,
+            filePath,
             dest,
             this.fileContextPath.toString(),
             [

packages/js-sdk/src/template/types.ts

@@ -101,6 +101,7 @@ export type Instruction = {
   forceUpload?: true
   filesHash?: string
   resolveSymlinks?: boolean
+  filePath?: string
 }
 
 /**

packages/js-sdk/src/template/utils.ts

@@ -4,6 +4,7 @@ import path from 'node:path'
 import { dynamicImport, dynamicRequire } from '../utils'
 import { BASE_STEP_NAME, FINALIZE_STEP_NAME } from './consts'
 import type { Path } from 'glob'
+import type { TarSource } from 'modern-tar/fs'
 
 /**
  * Read and parse a .dockerignore file.
@@ -33,6 +34,32 @@ function normalizePath(path: string): string {
   return path.replace(/\\/g, '/')
 }
 
+/**
+ * Convert a filesystem path to POSIX format for use in tar archives and Dockerfiles.
+ *
+ * Tar archives and Docker expect POSIX-style paths (forward slashes).
+ * On Windows, the drive letter (e.g., C:) is stripped and backslashes are converted.
+ *
+ * @param fsPath - The filesystem path to convert
+ * @returns The POSIX-formatted path suitable for tar/Docker
+ *
+ * @example
+ * ```ts
+ * toPosixPath('D:\\a\\E2B\\file.txt') // Returns 'a/E2B/file.txt'
+ * toPosixPath('/home/user/file.txt') // Returns 'home/user/file.txt'
+ * ```
+ */
+export function toPosixPath(fsPath: string): string {
+  // Normalize to forward slashes (POSIX format used by tar)
+  let posixPath = fsPath.replace(/\\/g, '/')
+  // Strip Windows drive letter (e.g., C:)
+  if (posixPath.length >= 2 && posixPath[1] === ':') {
+    posixPath = posixPath.slice(2)
+  }
+  // Strip leading slash
+  return posixPath.replace(/^\//, '')
+}
+
 /**
  * Get all files for a given path and ignore patterns.
  *
@@ -50,11 +77,18 @@ export async function getAllFilesInPath(
   const { glob } = await dynamicImport<typeof import('glob')>('glob')
   const files = new Map<string, Path>()
 
-  const globFiles = await glob(src, {
+  // For absolute paths, don't use cwd as glob will handle them directly
+  // For relative paths, use cwd to resolve relative to contextPath
+  const isAbsoluteSrc = path.isAbsolute(src)
+
+  // Normalize path separators for glob (glob expects forward slashes even on Windows)
+  const globPattern = normalizePath(src)
+  const cwd = isAbsoluteSrc ? process.cwd() : contextPath
+
+  const globFiles = await glob(globPattern, {
     ignore: ignorePatterns,
     withFileTypes: true,
-    // this is required so that the ignore pattern is relative to the file path
-    cwd: contextPath,
+    cwd,
   })
 
   for (const file of globFiles) {
@@ -63,16 +97,11 @@ export async function getAllFilesInPath(
       if (includeDirectories) {
         files.set(file.fullpath(), file)
       }
-      const dirPattern = normalizePath(
-        // When the matched directory is '.', `file.relative()` can be an empty string.
-        // In that case, we want to match all files under the current directory instead of
-        // creating an absolute glob like '/**/*' which would traverse the entire filesystem.
-        path.join(file.relative() || '.', '**/*')
-      )
+      const dirPattern = normalizePath(path.join(file.fullpath(), '**/*'))
       const dirFiles = await glob(dirPattern, {
         ignore: ignorePatterns,
         withFileTypes: true,
-        cwd: contextPath,
+        cwd,
       })
       dirFiles.forEach((f) => files.set(f.fullpath(), f))
     } else {
@@ -255,38 +284,66 @@ export function padOctal(mode: number): string {
 /**
  * Create a compressed tar stream of files matching a pattern.
  *
- * @param fileName Glob pattern for files to include
- * @param fileContextPath Base directory for resolving file paths
+ * @param filePath Original file path pattern (may include .. for outside-context files)
+ * @param fileContextPath Base directory for resolving relative paths
  * @param ignorePatterns Ignore patterns to exclude from the archive
  * @param resolveSymlinks Whether to follow symbolic links
  * @returns A readable stream of the gzipped tar archive
  */
 export async function tarFileStream(
-  fileName: string,
+  filePath: string,
   fileContextPath: string,
   ignorePatterns: string[],
   resolveSymlinks: boolean
 ) {
-  const { create } = await dynamicImport<typeof import('tar')>('tar')
+  const modernTar =
+    dynamicRequire<typeof import('modern-tar/fs')>('modern-tar/fs')
+  const zlib = dynamicRequire<typeof import('node:zlib')>('node:zlib')
 
   const allFiles = await getAllFilesInPath(
-    fileName,
+    filePath,
     fileContextPath,
     ignorePatterns,
     true
   )
 
-  const filePaths = allFiles.map((file) => file.relativePosix())
+  const sources: TarSource[] = allFiles.map((file) => {
+    const fullPath = file.fullpath()
+    const relativePath = file.relativePosix()
+
+    const asAbsolutePath =
+      path.isAbsolute(filePath) || filePath.startsWith('..')
+    const targetPath = asAbsolutePath ? toPosixPath(fullPath) : relativePath
 
-  return create(
-    {
-      gzip: true,
-      cwd: fileContextPath,
-      follow: resolveSymlinks,
-      noDirRecurse: true,
-    },
-    filePaths
-  )
+    if (file.isDirectory()) {
+      return {
+        type: 'directory' as const,
+        source: fullPath,
+        target: targetPath,
+      } as const
+    }
+
+    return {
+      type: 'file' as const,
+      source: fullPath,
+      target: targetPath,
+    } as const
+  })
+
+  // packTar returns a Node.js Readable stream
+  const tarStream = modernTar.packTar(sources, {
+    dereference: resolveSymlinks,
+  })
+
+  // Compress with gzip
+  const gzipStream = zlib.createGzip()
+
+  // Forward errors from tarStream to gzipStream to prevent hanging on errors
+  // (e.g., file read failure, permission issues)
+  tarStream.on('error', (err) => gzipStream.destroy(err))
+  tarStream.pipe(gzipStream)
+
+  return gzipStream
 }
 
 /**
@@ -298,14 +355,14 @@ export async function tarFileStream(
  * @returns Object containing the content length and upload stream
  */
 export async function tarFileStreamUpload(
-  fileName: string,
+  filePath: string,
   fileContextPath: string,
   ignorePatterns: string[],
   resolveSymlinks: boolean
 ) {
   // First pass: calculate the compressed size
   const sizeCalculationStream = await tarFileStream(
-    fileName,
+    filePath,
     fileContextPath,
     ignorePatterns,
     resolveSymlinks
@@ -318,7 +375,7 @@ export async function tarFileStreamUpload(
   return {
     contentLength,
     uploadStream: await tarFileStream(
-      fileName,
+      filePath,
       fileContextPath,
       ignorePatterns,
       resolveSymlinks
@@ -369,3 +426,25 @@ export function readGCPServiceAccountJSON(
   }
   return JSON.stringify(pathOrContent)
 }
+
+/**
+ * Rewrite the source path to the target path.
+ *
+ * For paths outside the context directory (starting with ..) or absolute paths,
+ * returns the full resolved path in POSIX format for Docker/tar compatibility.
+ *
+ * @param src Source path
+ * @param fileContextPath Base directory for resolving relative paths
+ * @returns The rewritten source path in POSIX format
+ */
+export function rewriteSrc(src: string, fileContextPath: string): string {
+  // For absolute paths, convert to POSIX format for Docker/tar compatibility
+  if (path.isAbsolute(src)) {
+    return toPosixPath(src)
+  }
+  // For paths outside of the context directory, return the full resolved path in POSIX format
+  if (src.startsWith('..')) {
+    return toPosixPath(path.resolve(fileContextPath, src))
+  }
+  return src
+}

packages/js-sdk/tests/template/build.test.ts

@@ -72,3 +72,20 @@ buildTemplateTest(
     await buildTemplate(template)
   }
 )
+
+buildTemplateTest(
+  'build template with absolute paths',
+  async ({ buildTemplate }) => {
+    const packageTxt = path.resolve(process.cwd(), folderPath, 'test.txt')
+
+    const template = Template()
+      // using base image to avoid re-building ubuntu:22.04 image
+      .fromBaseImage()
+      .skipCache()
+      .copy(packageTxt, 'text.txt', { forceUpload: true })
+      .copy('../../../../package.json', 'package.json', { forceUpload: true })
+      .runCmd(['ls -l .', 'cat text.txt', 'cat package.json'])
+
+    await buildTemplate(template, {}, defaultBuildLogger())
+  }
+)