goscript 0.1.3 → 0.1.4

package/gs/github.com/go-git/go-billy/v6/osfs/index.test.ts

@@ -0,0 +1,110 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as os from '@goscript/os/index.js'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { New } from './index.js'
+
+const roots: string[] = []
+
+afterEach(() => {
+  for (const root of roots.splice(0)) {
+    rmSync(root, { force: true, recursive: true })
+  }
+})
+
+function tempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'goscript-billy-osfs-'))
+  roots.push(root)
+  return root
+}
+
+describe('go-billy osfs override', () => {
+  it('writes through to the host directory used by os.DirFS', () => {
+    const root = tempRoot()
+    const fsys = New(root)
+
+    const [file, openErr] = fsys.OpenFile(
+      'README.md',
+      os.O_WRONLY | os.O_CREATE | os.O_TRUNC,
+      0o666,
+    )
+    expect(openErr).toBeNull()
+    const [n, writeErr] = file!.Write($.stringToBytes('hello\n'))
+    expect(writeErr).toBeNull()
+    expect(n).toBe(6)
+    expect(file!.Close()).toBeNull()
+
+    expect(readFileSync(join(root, 'README.md'), 'utf8')).toBe('hello\n')
+  })
+
+  it('keeps chrooted writes under the child host directory', () => {
+    const root = tempRoot()
+    const fsys = New(root)
+    const [child, chrootErr] = fsys.Chroot('sub')
+    expect(chrootErr).toBeNull()
+
+    const [file, openErr] = child!.Create('nested/file.txt')
+    expect(openErr).toBeNull()
+    const [, writeErr] = file!.Write($.stringToBytes('child'))
+    expect(writeErr).toBeNull()
+    expect(file!.Close()).toBeNull()
+
+    expect(readFileSync(join(root, 'sub', 'nested', 'file.txt'), 'utf8')).toBe(
+      'child',
+    )
+  })
+
+  it('rejects parent traversal outside the base directory', () => {
+    const root = tempRoot()
+    const fsys = New(root)
+
+    const [file, err] = fsys.Open('../escape.txt')
+
+    expect(file).toBeNull()
+    expect(err).not.toBeNull()
+  })
+
+  it('accepts absolute paths inside the base directory', () => {
+    const root = tempRoot()
+    const fsys = New(root)
+    const absolute = join(root, 'inside.txt')
+
+    const [file, openErr] = fsys.Create(absolute)
+    expect(openErr).toBeNull()
+    const [, writeErr] = file!.Write($.stringToBytes('inside'))
+    expect(writeErr).toBeNull()
+    expect(file!.Close()).toBeNull()
+
+    expect(readFileSync(absolute, 'utf8')).toBe('inside')
+  })
+
+  it('rejects absolute paths outside the base directory', () => {
+    const root = tempRoot()
+    const outside = tempRoot()
+    const fsys = New(root)
+
+    const [file, err] = fsys.Create(join(outside, 'outside.txt'))
+
+    expect(file).toBeNull()
+    expect(err).not.toBeNull()
+  })
+
+  it('reads host directory entries', () => {
+    const root = tempRoot()
+    writeFileSync(join(root, 'one.txt'), 'one')
+    writeFileSync(join(root, 'two.txt'), 'two')
+    const fsys = New(root)
+
+    const [entries, err] = fsys.ReadDir('.')
+
+    expect(err).toBeNull()
+    expect(
+      Array.from(entries ?? [])
+        .map((entry) => entry.Name())
+        .sort(),
+    ).toEqual(['one.txt', 'two.txt'])
+  })
+})

package/gs/github.com/go-git/go-billy/v6/osfs/index.ts

@@ -0,0 +1,280 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as fs from '@goscript/io/fs/index.js'
+import * as os from '@goscript/os/index.js'
+import * as filepath from '@goscript/path/filepath/index.js'
+
+export type Option = (o: options) => void
+export type Type = number
+
+export const BoundOSFS: Type = 0
+
+const allCapabilities = 127
+const defaultCreateMode = 0o666
+const defaultDirectoryMode = 0o777
+const ErrCrossedBoundary = $.newError('chroot boundary crossed')
+const ErrBaseDirCannotBeRemoved = $.newError('base dir cannot be removed')
+const ErrBaseDirCannotBeRenamed = $.newError('base dir cannot be renamed')
+
+type JoinElement = string | $.Slice<string>
+
+class options {
+  public Type: Type = BoundOSFS
+  public mmap = false
+}
+
+export function New(
+  baseDir: string,
+  ...opts: Array<Option | $.Slice<Option> | undefined>
+): BoundOS {
+  const o = new options()
+  for (const opt of normalizeOptions(opts)) {
+    opt(o)
+  }
+  return new BoundOS({ baseDir, mmap: o.mmap })
+}
+
+function normalizeOptions(
+  opts: Array<Option | $.Slice<Option> | undefined>,
+): Option[] {
+  if (opts.length === 0) {
+    return []
+  }
+  if (opts.length === 1 && typeof opts[0] !== 'function') {
+    const slice = opts[0] ?? null
+    const out: Option[] = []
+    for (let i = 0; i < $.len(slice); i++) {
+      out.push(slice![i])
+    }
+    return out
+  }
+  return opts.filter((opt): opt is Option => typeof opt === 'function')
+}
+
+export function WithBoundOS(): Option {
+  return (o: options): void => {
+    o.Type = BoundOSFS
+  }
+}
+
+export function WithMmap(): Option {
+  return (o: options): void => {
+    o.mmap = true
+  }
+}
+
+export class BoundOS {
+  public baseDir: string
+  public mmap: boolean
+
+  constructor(init?: Partial<{ baseDir?: string; mmap?: boolean }>) {
+    const baseDir = init?.baseDir ?? '/'
+    this.baseDir = baseDir === '' ? '/' : filepath.Clean(baseDir)
+    this.mmap = init?.mmap ?? false
+  }
+
+  public clone(): BoundOS {
+    return new BoundOS({ baseDir: this.baseDir, mmap: this.mmap })
+  }
+
+  public Capabilities(): number {
+    return allCapabilities
+  }
+
+  public Create(name: string): [os.File | null, $.GoError] {
+    return this.OpenFile(
+      name,
+      os.O_RDWR | os.O_CREATE | os.O_TRUNC,
+      defaultCreateMode,
+    )
+  }
+
+  public Open(name: string): [os.File | null, $.GoError] {
+    return this.OpenFile(name, os.O_RDONLY, 0)
+  }
+
+  public OpenFile(
+    name: string,
+    flag: number,
+    perm: fs.FileMode,
+  ): [os.File | null, $.GoError] {
+    const [full, err] = this.abs(name)
+    if (err !== null) {
+      return [null, err]
+    }
+    if ((flag & os.O_CREATE) !== 0) {
+      const dir = filepath.Dir(full)
+      if (dir !== '.' && dir !== '') {
+        const mkdirErr = os.MkdirAll(dir, defaultDirectoryMode)
+        if (mkdirErr !== null) {
+          return [null, mkdirErr]
+        }
+      }
+    }
+    return os.OpenFile(full, flag, perm)
+  }
+
+  public Stat(name: string): [fs.FileInfo, $.GoError] {
+    const [full, err] = this.abs(name)
+    if (err !== null) {
+      return [null, err]
+    }
+    return os.Stat(full)
+  }
+
+  public Lstat(name: string): [fs.FileInfo, $.GoError] {
+    const [full, err] = this.abs(name)
+    if (err !== null) {
+      return [null, err]
+    }
+    return os.Lstat(full)
+  }
+
+  public ReadDir(name: string): [$.Slice<fs.DirEntry>, $.GoError] {
+    const [full, err] = this.abs(name)
+    if (err !== null) {
+      return [null, err]
+    }
+    const [file, openErr] = os.Open(full)
+    if (openErr !== null) {
+      return [null, openErr]
+    }
+    const [entries, readErr] = file!.ReadDir(-1)
+    const closeErr = file!.Close()
+    return [entries, readErr ?? closeErr]
+  }
+
+  public Rename(from: string, to: string): $.GoError {
+    if (this.isRoot(from)) {
+      return ErrBaseDirCannotBeRenamed
+    }
+    const [fromFull, fromErr] = this.abs(from)
+    if (fromErr !== null) {
+      return fromErr
+    }
+    const [toFull, toErr] = this.abs(to)
+    if (toErr !== null) {
+      return toErr
+    }
+    const mkdirErr = os.MkdirAll(filepath.Dir(toFull), defaultDirectoryMode)
+    if (mkdirErr !== null) {
+      return mkdirErr
+    }
+    return os.Rename(fromFull, toFull)
+  }
+
+  public Remove(name: string): $.GoError {
+    if (this.isRoot(name)) {
+      return ErrBaseDirCannotBeRemoved
+    }
+    const [full, err] = this.abs(name)
+    if (err !== null) {
+      return err
+    }
+    return os.Remove(full)
+  }
+
+  public RemoveAll(name: string): $.GoError {
+    if (this.isRoot(name)) {
+      return ErrBaseDirCannotBeRemoved
+    }
+    const [full, err] = this.abs(name)
+    if (err !== null) {
+      return err
+    }
+    return os.RemoveAll(full)
+  }
+
+  public MkdirAll(name: string, perm: fs.FileMode): $.GoError {
+    const [full, err] = this.abs(name)
+    if (err !== null) {
+      return err
+    }
+    return os.MkdirAll(full, perm)
+  }
+
+  public Symlink(target: string, link: string): $.GoError {
+    const [full, err] = this.abs(link)
+    if (err !== null) {
+      return err
+    }
+    const mkdirErr = os.MkdirAll(filepath.Dir(full), defaultDirectoryMode)
+    if (mkdirErr !== null) {
+      return mkdirErr
+    }
+    return os.Symlink(target, full)
+  }
+
+  public Readlink(link: string): [string, $.GoError] {
+    const [full, err] = this.abs(link)
+    if (err !== null) {
+      return ['', err]
+    }
+    return os.Readlink(full)
+  }
+
+  public TempFile(dir: string, prefix: string): [os.File | null, $.GoError] {
+    const targetDir = dir === '' ? '.tmp' : dir
+    const [fullDir, err] = this.abs(targetDir)
+    if (err !== null) {
+      return [null, err]
+    }
+    const mkdirErr = os.MkdirAll(fullDir, defaultDirectoryMode)
+    if (mkdirErr !== null) {
+      return [null, mkdirErr]
+    }
+    return os.CreateTemp(fullDir, prefix === '' ? 'tmp-*' : prefix + '*')
+  }
+
+  public Join(...elem: JoinElement[]): string {
+    if (elem.length === 1 && typeof elem[0] !== 'string') {
+      return filepath.Join(elem[0])
+    }
+    return filepath.Join(...(elem as string[]))
+  }
+
+  public Chroot(path: string): [BoundOS | null, $.GoError] {
+    const [full, err] = this.abs(path)
+    if (err !== null) {
+      return [null, err]
+    }
+    return [new BoundOS({ baseDir: full, mmap: this.mmap }), null]
+  }
+
+  public Root(): string {
+    return this.baseDir
+  }
+
+  private isRoot(name: string): boolean {
+    return name === '' || name === '.'
+  }
+
+  private abs(name: string): [string, $.GoError] {
+    if (this.isRoot(name)) {
+      return [this.baseDir, null]
+    }
+    const normalized = filepath.Clean(filepath.ToSlash(name))
+    if (filepath.IsAbs(normalized)) {
+      const full = filepath.Clean(filepath.FromSlash(normalized))
+      if (!this.insideBase(full)) {
+        return ['', ErrCrossedBoundary]
+      }
+      return [full, null]
+    }
+    if (normalized === '..' || normalized.startsWith('../')) {
+      return ['', ErrCrossedBoundary]
+    }
+    return [filepath.Join(this.baseDir, filepath.FromSlash(normalized)), null]
+  }
+
+  private insideBase(path: string): boolean {
+    const full = filepath.Clean(path)
+    if (full === this.baseDir) {
+      return true
+    }
+    return full.startsWith(
+      this.baseDir.endsWith('/') ? this.baseDir : this.baseDir + '/',
+    )
+  }
+}
+
+export const Default = New('/')

package/gs/github.com/go-git/go-billy/v6/osfs/meta.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": [
+    "io/fs",
+    "os",
+    "path/filepath"
+  ],
+  "asyncMethods": {}
+}

package/gs/io/fs/readdir.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { File, FileInfo, ReadDir } from './index.js'
+
+describe('io/fs ReadDir override', () => {
+  it('returns a nil entry slice without sorting when directory read fails', () => {
+    const readErr = $.newError('read failed')
+    const file: File & {
+      ReadDir(n: number): [null, $.GoError]
+    } = {
+      Close(): $.GoError {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, readErr]
+      },
+      Stat(): [FileInfo, $.GoError] {
+        return [null, readErr]
+      },
+      ReadDir(_n: number): [null, $.GoError] {
+        return [null, readErr]
+      },
+    }
+
+    const [list, err] = ReadDir(
+      {
+        Open(_name: string): [File, $.GoError] {
+          return [file, null]
+        },
+      },
+      'dir',
+    )
+
+    expect(list).toBeNull()
+    expect(err).toBe(readErr)
+  })
+})

package/gs/io/fs/readdir.ts

@@ -92,9 +92,13 @@ export function ReadDir(
 
   let list: $.Slice<DirEntry>
   ;[list, err] = dir!.ReadDir(-1)
-  list!.sort((a: DirEntry, b: DirEntry): number => {
-    return a!.Name().localeCompare(b!.Name())
-  })
+  if (list) {
+    list.sort((a: DirEntry, b: DirEntry): number => {
+      return $.pointerValue<Exclude<DirEntry, null>>(a).Name().localeCompare(
+        $.pointerValue<Exclude<DirEntry, null>>(b).Name(),
+      )
+    })
+  }
   return [list, err]
 }
 

package/gs/io/io.test.ts

@@ -1,5 +1,5 @@
 import * as $ from '@goscript/builtin/index.js'
-import { LimitedReader, MultiWriter, TeeReader } from './index.js'
+import { LimitedReader, MultiWriter, NopCloser, Pipe, TeeReader } from './index.js'
 import { describe, expect, test } from 'vitest'
 
 class sliceReader {
@@ -9,7 +9,7 @@ class sliceReader {
     const n = Math.min($.len(p), this.data.length)
     p!.set(this.data.subarray(0, n), 0)
     this.data = this.data.subarray(n)
-    return [n, n === 0 ? new Error('EOF') as $.GoError : null]
+    return [n, n === 0 ? (new Error('EOF') as $.GoError) : null]
   }
 }
 
@@ -37,28 +37,99 @@ describe('io override', () => {
     expect(Buffer.from(buf.subarray(0, n)).toString('utf8')).toBe('abc')
   })
 
-  test('TeeReader accepts nullable generated interface values', () => {
+  test('TeeReader accepts nullable generated interface values', async () => {
     const writer = new captureWriter()
     const reader = TeeReader(new sliceReader($.stringToBytes('abc')), writer)
     const buf = new Uint8Array(4)
 
-    const [n, err] = reader.Read(buf)
+    const [n, err] = await reader.Read(buf)
 
     expect(err).toBeNull()
     expect(n).toBe(3)
     expect(Buffer.from(writer.chunks).toString('utf8')).toBe('abc')
   })
 
-  test('MultiWriter accepts nullable generated interface values', () => {
+  test('NopCloser accepts nullable generated interface values', () => {
+    const reader: sliceReader | null = new sliceReader($.stringToBytes('abc'))
+    const body = NopCloser(reader)
+    const buf = new Uint8Array(4)
+
+    const [n, err] = body.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(body.Close()).toBeNull()
+  })
+
+  test('TeeReader awaits async readers and writers', async () => {
+    const chunks: number[] = []
+    const reader = TeeReader(
+      {
+        async Read(p: $.Bytes): Promise<[number, $.GoError]> {
+          await Promise.resolve()
+          p!.set($.stringToBytes('abc'), 0)
+          return [3, null]
+        },
+      } as any,
+      {
+        async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+          await Promise.resolve()
+          chunks.push(...Array.from(p ?? []))
+          return [$.len(p), null]
+        },
+      } as any,
+    )
+    const buf = new Uint8Array(4)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('MultiWriter accepts nullable generated interface values', async () => {
     const first = new captureWriter()
     const second = new captureWriter()
     const writer = MultiWriter(first, second)
 
-    const [n, err] = writer.Write($.stringToBytes('abc'))
+    const [n, err] = await writer.Write($.stringToBytes('abc'))
 
     expect(err).toBeNull()
     expect(n).toBe(3)
     expect(Buffer.from(first.chunks).toString('utf8')).toBe('abc')
     expect(Buffer.from(second.chunks).toString('utf8')).toBe('abc')
   })
+
+  test('MultiWriter awaits async generated writers', async () => {
+    const chunks: number[] = []
+    const writer = MultiWriter({
+      async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+        await Promise.resolve()
+        chunks.push(...Array.from(p ?? []))
+        return [$.len(p), null]
+      },
+    })
+
+    const [n, err] = await writer.Write($.stringToBytes('abc'))
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('PipeReader waits for a later write', async () => {
+    const [reader, writer] = Pipe()
+    const buf = new Uint8Array(5)
+
+    const read = reader.Read(buf)
+    const [written, writeErr] = await writer.Write($.stringToBytes('later'))
+    const [readBytes, readErr] = await read
+
+    expect(writeErr).toBeNull()
+    expect(written).toBe(5)
+    expect(readErr).toBeNull()
+    expect(readBytes).toBe(5)
+    expect(Buffer.from(buf).toString('utf8')).toBe('later')
+  })
 })