goscript 0.1.2 → 0.1.4

package/gs/fmt/meta.json

@@ -1,5 +1,10 @@
 {
+  "asyncFunctions": {
+    "Fprint": true,
+    "Fprintf": true,
+    "Fprintln": true
+  },
   "dependencies": [
     "errors"
   ]
-} 
+}

package/gs/github.com/aperturerobotics/starpc/srpc/index.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it } from 'vitest'
 
 import * as context from '@goscript/context/index.js'
+import * as $ from '@goscript/builtin/index.js'
 
-import { MuxedConn, NewWebSocketConn } from './index.js'
+import { MuxedConn, NewClientSet, NewPrefixClient, NewWebSocketConn } from './index.js'
 
 describe('starpc/srpc override', () => {
   it('wraps websocket connections with the same outbound direction as Go', () => {
@@ -28,4 +29,10 @@ describe('starpc/srpc override', () => {
     expect(serverConn?.outbound).toBe(false)
     expect(clientConn?.outbound).toBe(true)
   })
+
+  it('registers prefixed clients as srpc.Client values', () => {
+    const client = NewPrefixClient(NewClientSet(null), ['plugin-host/'])
+
+    expect($.typeAssert(client, 'srpc.Client').ok).toBe(true)
+  })
 })

package/gs/github.com/aperturerobotics/starpc/srpc/index.ts

@@ -115,6 +115,33 @@ export interface Client {
   ): Promise<[Stream | null, $.GoError]>
 }
 
+$.registerInterfaceType('srpc.Client', null, [
+  {
+    name: 'ExecCall',
+    args: [
+      { name: 'ctx', type: 'context.Context' },
+      { name: 'service', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'method', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'in', type: 'srpc.Message' },
+      { name: 'out', type: 'srpc.Message' },
+    ],
+    returns: [{ name: '_r0', type: 'error' }],
+  },
+  {
+    name: 'NewStream',
+    args: [
+      { name: 'ctx', type: 'context.Context' },
+      { name: 'service', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'method', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'firstMsg', type: 'srpc.Message' },
+    ],
+    returns: [
+      { name: '_r0', type: 'srpc.Stream' },
+      { name: '_r1', type: 'error' },
+    ],
+  },
+])
+
 export class ClientSet implements Client {
   private clients: $.Slice<Client | null>
 
@@ -395,6 +422,84 @@ class memoryStream implements Stream {
   }
 }
 
+class streamQueue {
+  private queue: (Message | null)[] = []
+  private waiters: ((msg: Message | null, err: $.GoError) => void)[] = []
+  private closed = false
+
+  public send(msg: Message | null): $.GoError {
+    if (this.closed) {
+      return ErrCompleted
+    }
+    const waiter = this.waiters.shift()
+    if (waiter != null) {
+      waiter(msg, null)
+      return null
+    }
+    this.queue.push(msg)
+    return null
+  }
+
+  public recv(msg: Message | null): MaybePromise<$.GoError> {
+    const next = this.queue.shift()
+    if (next !== undefined) {
+      if (msg != null && next != null) {
+        Object.assign(msg, next)
+      }
+      return null
+    }
+    if (this.closed) {
+      return io.EOF
+    }
+    return new Promise<$.GoError>((resolve) => {
+      this.waiters.push((sent, err) => {
+        if (msg != null && sent != null) {
+          Object.assign(msg, sent)
+        }
+        resolve(err)
+      })
+    })
+  }
+
+  public close(): $.GoError {
+    this.closed = true
+    for (const waiter of this.waiters.splice(0)) {
+      waiter(null, io.EOF)
+    }
+    return null
+  }
+}
+
+class pairedMemoryStream implements Stream {
+  constructor(
+    private ctx: context.Context,
+    private incoming: streamQueue,
+    private outgoing: streamQueue,
+  ) {}
+
+  public Context(): context.Context {
+    return this.ctx
+  }
+
+  public MsgSend(msg: Message | null): $.GoError {
+    return this.outgoing.send(msg)
+  }
+
+  public MsgRecv(msg: Message | null): MaybePromise<$.GoError> {
+    return this.incoming.recv(msg)
+  }
+
+  public CloseSend(): $.GoError {
+    return this.outgoing.close()
+  }
+
+  public Close(): $.GoError {
+    const incomingErr = this.incoming.close()
+    const outgoingErr = this.outgoing.close()
+    return incomingErr ?? outgoingErr
+  }
+}
+
 class streamWithClose implements Stream {
   constructor(
     private stream: Stream,
@@ -738,7 +843,7 @@ class transportClient implements Client {
     if (output != null) {
       output.Reset()
     }
-    return await writer?.Close() ?? null
+    return (await writer?.Close()) ?? null
   }
 
   public async NewStream(
@@ -792,7 +897,9 @@ export function NewClient(openStream: OpenStreamFunc | null): Client {
 class invokerClient implements Client {
   constructor(
     private invoker: Invoker | null,
-    private contextFn: ((ctx: context.Context) => context.Context) | null = null,
+    private contextFn:
+      | ((ctx: context.Context) => context.Context)
+      | null = null,
   ) {}
 
   public async ExecCall(
@@ -833,19 +940,36 @@ class invokerClient implements Client {
     if (this.invoker == null) {
       return [null, ErrNoAvailableClients]
     }
-    const stream = new memoryStream(
-      this.contextFn == null ? ctx : this.contextFn(ctx),
-      firstMsg,
+    const streamCtx = this.contextFn == null ? ctx : this.contextFn(ctx)
+    const clientInput = new streamQueue()
+    const serverInput = new streamQueue()
+    const clientStream = new pairedMemoryStream(
+      streamCtx,
+      clientInput,
+      serverInput,
+    )
+    const serverStream = new pairedMemoryStream(
+      streamCtx,
+      serverInput,
+      clientInput,
     )
+    if (firstMsg != null) {
+      const err = serverInput.send(firstMsg)
+      if (err != null) {
+        return [null, err]
+      }
+    }
     const pending = Promise.resolve(
-      this.invoker.InvokeMethod(service, method, stream),
+      this.invoker.InvokeMethod(service, method, serverStream),
     )
     pending.then(([handled, err]) => {
       if (!handled || err != null) {
-        stream.Close()
+        clientStream.Close()
+        return
       }
+      serverStream.CloseSend()
     })
-    return [stream, null]
+    return [clientStream, null]
   }
 }
 
@@ -936,7 +1060,9 @@ export class ServerRPC {
       stream,
     )
     const callErr = err ?? (handled ? null : ErrUnimplemented)
-    await this.writer?.WritePacket(NewCallDataPacket(null, false, true, callErr))
+    await this.writer?.WritePacket(
+      NewCallDataPacket(null, false, true, callErr),
+    )
     return callErr
   }
 
@@ -995,8 +1121,10 @@ export function NewServerPipe(server: Server | null): OpenStreamFunc {
     _ctx: context.Context,
     _msgHandler: PacketDataHandler,
     _closeHandler: CloseHandler,
-  ): [PacketWriter | null, $.GoError] => [new closedPacketWriter(), null]) as
-    OpenStreamFunc
+  ): [PacketWriter | null, $.GoError] => [
+    new closedPacketWriter(),
+    null,
+  ]) as OpenStreamFunc
   if (server != null) {
     openStream.__server = server
   }

package/gs/github.com/aperturerobotics/util/conc/index.test.ts

@@ -25,6 +25,6 @@ describe('util/conc override', () => {
 
     release.close()
     expect(await q.WaitIdle(Background(), null)).toBeNull()
-    expect(done).toEqual([0, 1, 2, 3, 4])
+    expect([...done].sort((a, b) => a - b)).toEqual([0, 1, 2, 3, 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]
 }