goscript 0.1.3 → 0.2.0

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/github.com/pkg/errors/errors.ts

@@ -109,10 +109,18 @@ class fundamental {
       },
     ],
     fundamental,
-    {
-      msg: { kind: $.TypeKind.Basic, name: 'string' },
-      stack: { kind: $.TypeKind.Pointer, elemType: 'stack' },
-    },
+    [
+      {
+        name: 'msg',
+        key: 'msg',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+      {
+        name: 'stack',
+        key: 'stack',
+        type: { kind: $.TypeKind.Pointer, elemType: 'stack' },
+      },
+    ],
   )
 }
 
@@ -231,20 +239,28 @@ class withStack {
       },
     ],
     withStack,
-    {
-      error: {
-        kind: $.TypeKind.Interface,
-        name: 'GoError',
-        methods: [
-          {
-            name: 'Error',
-            args: [],
-            returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-          },
-        ],
+    [
+      {
+        name: 'error',
+        key: 'error',
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
+        },
       },
-      stack: { kind: $.TypeKind.Pointer, elemType: 'stack' },
-    },
+      {
+        name: 'stack',
+        key: 'stack',
+        type: { kind: $.TypeKind.Pointer, elemType: 'stack' },
+      },
+    ],
   )
 }
 
@@ -405,20 +421,28 @@ class withMessage {
       },
     ],
     withMessage,
-    {
-      cause: {
-        kind: $.TypeKind.Interface,
-        name: 'GoError',
-        methods: [
-          {
-            name: 'Error',
-            args: [],
-            returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-          },
-        ],
+    [
+      {
+        name: 'cause',
+        key: 'cause',
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
+        },
       },
-      msg: { kind: $.TypeKind.Basic, name: 'string' },
-    },
+      {
+        name: 'msg',
+        key: 'msg',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+    ],
   )
 }
 

package/gs/go/scanner/index.test.ts

@@ -3,70 +3,53 @@ import { describe, expect, it } from 'vitest'
 import * as $ from '@goscript/builtin/index.js'
 import * as token from '@goscript/go/token/index.js'
 
-import {
-  ErrorList_Add,
-  ErrorList_Err,
-  ErrorList_Error,
-  ErrorList_Len,
-  ErrorList_RemoveMultiples,
-  Scanner,
-  type ErrorList,
-} from './index.js'
+import { Error as ScannerError, ErrorList_Err, PrintError } from './index.js'
 
 describe('go/scanner override', () => {
-  it('adds and formats scanner errors', () => {
-    const list: $.VarRef<ErrorList> = $.varRef(null)
-
-    ErrorList_Add(
-      list,
-      $.markAsStructValue(
-        new token.Position({
-          Filename: 'test.go',
-          Line: 1,
-          Column: 1,
-        }),
-      ),
-      'test error',
-    )
-
-    expect(ErrorList_Len(list.value)).toBe(1)
-    expect(ErrorList_Error(list.value)).toBe('test.go:1:1: test error')
+  it('prints errors to an io.Writer', () => {
+    const chunks: string[] = []
+    const writer = {
+      Write(p: $.Bytes): [number, $.GoError] {
+        chunks.push($.bytesToString(p))
+        return [$.len(p), null]
+      },
+    }
+
+    PrintError(writer, $.newError('scan failed'))
+
+    expect(chunks).toEqual(['scan failed\n'])
   })
 
-  it('removes repeated line errors', () => {
-    const list: $.VarRef<ErrorList> = $.varRef(null)
-    const pos = $.markAsStructValue(
-      new token.Position({
-        Filename: 'test.go',
-        Line: 1,
-        Column: 1,
+  it('prints every ErrorList entry', () => {
+    const chunks: string[] = []
+    const writer = {
+      Write(p: $.Bytes): [number, $.GoError] {
+        chunks.push($.bytesToString(p))
+        return [$.len(p), null]
+      },
+    }
+
+    const errors = [
+      new ScannerError({
+        Pos: new token.Position({ Filename: 'a.go', Line: 1, Column: 2 }),
+        Msg: 'first',
       }),
-    )
-
-    ErrorList_Add(list, pos, 'first')
-    ErrorList_Add(list, pos, 'second')
-    ErrorList_RemoveMultiples(list)
-
-    expect(ErrorList_Len(list.value)).toBe(1)
-  })
-
-  it('returns nil Err for an empty list and an error for non-empty lists', () => {
-    const empty: ErrorList = null
-    expect(ErrorList_Err(empty)).toBeNull()
+      new ScannerError({
+        Pos: new token.Position({ Filename: 'a.go', Line: 3, Column: 4 }),
+        Msg: 'second',
+      }),
+    ]
 
-    const list: $.VarRef<ErrorList> = $.varRef(null)
-    ErrorList_Add(list, new token.Position({ Line: 1 }), 'first')
-    expect(ErrorList_Err(list.value)?.Error()).toBe('1: first')
-  })
+    PrintError(writer, errors as $.GoError)
 
-  it('provides a Scanner surface for generated go/parser code', () => {
-    const fset = token.NewFileSet()
-    const file = fset.AddFile('test.go', -1, 0)
-    const scanner = new Scanner()
+    expect(chunks).toEqual(['a.go:1:2: first\n', 'a.go:3:4: second\n'])
 
-    scanner.Init(file, null, null, 0)
+    chunks.length = 0
+    const err = ErrorList_Err(errors)
+    expect(Array.isArray(err)).toBe(true)
+    expect(err?.Error()).toBe('a.go:1:2: first (and 1 more errors)')
+    PrintError(writer, err)
 
-    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
-    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
+    expect(chunks).toEqual(['a.go:1:2: first\n', 'a.go:3:4: second\n'])
   })
 })

package/gs/go/scanner/index.ts

@@ -1,5 +1,6 @@
 import * as $ from '@goscript/builtin/index.js'
 import * as token from '@goscript/go/token/index.js'
+import type * as io from '@goscript/io/index.js'
 
 export class Error {
   public get Pos(): token.Position {
@@ -54,10 +55,14 @@ export class Error {
       },
     ],
     Error,
-    {
-      Pos: { type: 'go/token.Position' },
-      Msg: { kind: $.TypeKind.Basic, name: 'string' },
-    },
+    [
+      { name: 'Pos', key: 'Pos', type: 'go/token.Position' },
+      {
+        name: 'Msg',
+        key: 'Msg',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+    ],
   )
 }
 
@@ -196,9 +201,32 @@ export function ErrorList_Error(list: ErrorList): string {
   return `${errors[0]!.Error()} (and ${errors.length - 1} more errors)`
 }
 
+type errorListWithError = ErrorList & { Error?: () => string }
+
 export function ErrorList_Err(list: ErrorList): $.GoError {
   if ($.len(list) === 0) {
     return null
   }
-  return $.newError(ErrorList_Error(list))
+  const err = list as errorListWithError
+  err.Error = () => ErrorList_Error(list)
+  return err as unknown as $.GoError
+}
+
+export function PrintError(w: io.Writer, err: $.GoError): void {
+  if (err === null) {
+    return
+  }
+  if (Array.isArray(err)) {
+    for (const entry of Array.from((err as ErrorList) ?? [])) {
+      if (entry == null) {
+        continue
+      }
+      w.Write($.stringToBytes(`${entry.Error()}\n`))
+    }
+    return
+  }
+  const text = err.Error()
+  for (const line of text.split('\n')) {
+    w.Write($.stringToBytes(line + '\n'))
+  }
 }

package/gs/go/scanner/parity.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Error": {
+      "status": "real"
+    },
+    "ErrorHandler": {
+      "status": "real"
+    },
+    "ErrorList": {
+      "status": "real"
+    },
+    "Mode": {
+      "status": "real"
+    },
+    "PrintError": {
+      "status": "real"
+    },
+    "ScanComments": {
+      "status": "real"
+    },
+    "Scanner": {
+      "status": "real"
+    }
+  }
+}