goscript 0.0.83 → 0.1.0

package/gs/os/tempfile.gs.test.ts

@@ -0,0 +1,85 @@
+import { basename, join } from 'node:path'
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { ErrUnimplemented } from './error.gs.js'
+import { CreateTemp, MkdirTemp } from './tempfile.gs.js'
+
+const tempRoots: string[] = []
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  vi.unstubAllGlobals()
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { force: true, recursive: true })
+  }
+})
+
+function makeTempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'goscript-os-temp-'))
+  tempRoots.push(root)
+  return root
+}
+
+function stubRandomBytes(bytes: number[]): void {
+  vi.stubGlobal('crypto', {
+    getRandomValues: vi.fn((dst: Uint8Array) => {
+      for (let i = 0; i < dst.length; i++) {
+        dst[i] = bytes[i] ?? 0
+      }
+      return dst
+    }),
+  })
+}
+
+function forbidMathRandom(): void {
+  vi.spyOn(Math, 'random').mockImplementation(() => {
+    throw new Error('os temp names must not use Math.random')
+  })
+}
+
+describe('os temp files', () => {
+  it('uses Web Crypto bytes for temp names', () => {
+    const root = makeTempRoot()
+    stubRandomBytes([0x78, 0x56, 0x34, 0x12])
+    forbidMathRandom()
+
+    const [dir, dirErr] = MkdirTemp(root, 'dir-*.tmp')
+    expect(dirErr).toBeNull()
+    expect(basename(dir)).toBe('dir-305419896.tmp')
+    expect(existsSync(dir)).toBe(true)
+
+    const [file, fileErr] = CreateTemp(root, 'file-*.tmp')
+    expect(fileErr).toBeNull()
+    expect(file).not.toBeNull()
+    expect(basename(file!.Name())).toBe('file-305419896.tmp')
+    expect(existsSync(file!.Name())).toBe(true)
+    file!.Close()
+  })
+
+  it('does not truncate an existing path after a random collision', () => {
+    const root = makeTempRoot()
+    const existing = join(root, 'file-305419896.tmp')
+    writeFileSync(existing, 'keep')
+    stubRandomBytes([0x78, 0x56, 0x34, 0x12])
+    forbidMathRandom()
+
+    const [file, err] = CreateTemp(root, 'file-*.tmp')
+
+    expect(file).toBeNull()
+    expect(err).not.toBeNull()
+    expect(readFileSync(existing, 'utf8')).toBe('keep')
+  })
+
+  it('reports ErrUnimplemented without a secure random source', () => {
+    const root = makeTempRoot()
+    vi.stubGlobal('crypto', {})
+    forbidMathRandom()
+
+    const [dir, err] = MkdirTemp(root, 'dir-*')
+
+    expect(dir).toBe('')
+    expect(err).toBe(ErrUnimplemented)
+  })
+})

package/gs/os/tempfile.gs.ts

@@ -1,8 +1,8 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
 import { TempDir } from "./file_constants_js.gs.js";
-import { Create, Mkdir } from "./file_js.gs.js";
-import { File } from "./types_js.gs.js";
+import { Mkdir } from "./file_js.gs.js";
+import { createHostFile, File, getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
 
 export function joinPath(dir: string, file: string): string {
   if (dir === "" || dir === ".") {
@@ -20,33 +20,93 @@ export function joinPath(dir: string, file: string): string {
   return dir + "/" + file
 }
 
-function nextTempPath(dir: string, pattern: string): string {
+function nextTempPath(dir: string, pattern: string): [string, $.GoError] {
   const baseDir = dir === "" ? TempDir() : dir
-  const suffix = Math.random().toString(36).slice(2, 10) + Date.now().toString(36)
-  const name = pattern.includes("*") ? pattern.replace("*", suffix) : pattern + suffix
-  return joinPath(baseDir, name)
+  const [suffix, err] = nextRandom()
+  if (err !== null) {
+    return ["", err]
+  }
+  const star = pattern.lastIndexOf("*")
+  const name =
+    star >= 0
+      ? pattern.slice(0, star) + suffix + pattern.slice(star + 1)
+      : pattern + suffix
+  return [joinPath(baseDir, name), null]
+}
+
+function nextRandom(): [string, $.GoError] {
+  const crypto = globalThis.crypto
+  if (!crypto || typeof crypto.getRandomValues !== "function") {
+    return ["", ErrUnimplemented]
+  }
+  const bytes = new Uint8Array(4)
+  crypto.getRandomValues(bytes)
+  const value =
+    bytes[0] |
+    (bytes[1] << 8) |
+    (bytes[2] << 16) |
+    (bytes[3] << 24)
+  return [(value >>> 0).toString(10), null]
+}
+
+function createTempFile(path: string): [File | null, $.GoError] {
+  const denoObj = getDeno()
+  if (denoObj?.openSync) {
+    try {
+      const handle = denoObj.openSync(path, {
+        createNew: true,
+        mode: 0o600,
+        read: true,
+        write: true,
+      })
+      return [createHostFile(path, handle?.rid ?? -1, handle), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
+
+  const nodeFS = getNodeFS()
+  if (nodeFS?.openSync) {
+    try {
+      return [createHostFile(path, nodeFS.openSync(path, "wx+", 0o600)), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
+
+  return [null, ErrUnimplemented]
 }
 
 export function CreateTemp(dir: string, pattern: string): [File | null, $.GoError] {
   const template = pattern === "" ? "tmp-*" : pattern
+  let lastErr: $.GoError = ErrUnimplemented
   for (let i = 0; i < 16; i++) {
-    const path = nextTempPath(dir, template)
-    const [file, err] = Create(path)
+    const [path, randErr] = nextTempPath(dir, template)
+    if (randErr !== null) {
+      return [null, randErr]
+    }
+    const [file, err] = createTempFile(path)
     if (err === null) {
       return [file, null]
     }
+    lastErr = err
   }
-  return [null, ErrUnimplemented]
+  return [null, lastErr]
 }
 
 export function MkdirTemp(dir: string, pattern: string): [string, $.GoError] {
   const template = pattern === "" ? "tmp-*" : pattern
+  let lastErr: $.GoError = ErrUnimplemented
   for (let i = 0; i < 16; i++) {
-    const path = nextTempPath(dir, template)
+    const [path, randErr] = nextTempPath(dir, template)
+    if (randErr !== null) {
+      return ["", randErr]
+    }
     const err = Mkdir(path, 0o700)
     if (err === null) {
       return [path, null]
     }
+    lastErr = err
   }
-  return ["", ErrUnimplemented]
+  return ["", lastErr]
 }

package/gs/os/types_js.gs.ts

@@ -5,50 +5,16 @@ import * as fs from "@goscript/io/fs/index.js"
 import * as io from "@goscript/io/index.js"
 import * as time from "@goscript/time/index.js"
 import * as syscall from "@goscript/syscall/index.js"
+import {
+	DenoFileLike,
+	DenoStream,
+	getHostRuntime,
+	HostUnsupportedError,
+	NodeFSModule,
+	resetHostRuntimeForTests,
+} from "@goscript/builtin/hostio.js"
 import { newRawConn } from "./rawconn_js.gs.js"
 
-export type NodeFSModule = {
-	readSync(fd: number, buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number
-	writeSync(fd: number, buffer: Uint8Array, offset?: number, length?: number, position?: number | null): number
-	closeSync?(fd: number): void
-	fstatSync?(fd: number): HostStatLike
-	fsyncSync?(fd: number): void
-	ftruncateSync?(fd: number, len?: number): void
-	openSync?(path: string, flags: number | string, mode?: number): number
-	chmodSync?(path: string, mode: number): void
-	chownSync?(path: string, uid: number, gid: number): void
-	lchownSync?(path: string, uid: number, gid: number): void
-	linkSync?(existingPath: string, newPath: string): void
-	lstatSync?(path: string): HostStatLike
-	mkdirSync?(path: string, options?: number | { mode?: number, recursive?: boolean }): void
-	readFileSync?(path: string): Uint8Array
-	readdirSync?(path: string, options?: { withFileTypes?: boolean }): any[]
-	readlinkSync?(path: string): string
-	renameSync?(oldPath: string, newPath: string): void
-	rmSync?(path: string, options?: { force?: boolean, recursive?: boolean }): void
-	rmdirSync?(path: string): void
-	statSync?(path: string): HostStatLike
-	symlinkSync?(target: string, path: string): void
-	truncateSync?(path: string, len?: number): void
-	unlinkSync?(path: string): void
-	utimesSync?(path: string, atime: Date | number, mtime: Date | number): void
-	writeFileSync?(path: string, data: Uint8Array, options?: { mode?: number }): void
-}
-
-export type DenoStream = {
-	readSync?(buffer: Uint8Array): number | null
-	writeSync?(buffer: Uint8Array): number
-}
-
-export type DenoFileLike = DenoStream & {
-	close?(): void
-	rid?: number
-	seekSync?(offset: number, whence: number): number
-	syncSync?(): void
-	statSync?(): HostStatLike
-	truncateSync?(len?: number): void
-}
-
 export type HostStatLike = {
 	isDirectory(): boolean
 	isSymbolicLink?(): boolean
@@ -66,90 +32,24 @@ export function newHostError(err: unknown): $.GoError {
 	return { Error: () => message }
 }
 
-export function getDynamicRequire(): ((specifier: string) => unknown) | null {
-	try {
-		return Function(
-			"return typeof require !== 'undefined' ? require : null",
-		)() as ((specifier: string) => unknown) | null
-	} catch {
-		return null
-	}
-}
-
 export function getNodeFS(): NodeFSModule | null {
-	const processObj = (globalThis as any).process
-	if (processObj && typeof processObj.getBuiltinModule === "function") {
-		const module = processObj.getBuiltinModule("fs")
-		if (module && typeof module.readSync === "function" && typeof module.writeSync === "function") {
-			return module as NodeFSModule
-		}
-	}
-
-	const requireFn = getDynamicRequire()
-	if (requireFn) {
-		for (const specifier of ["node:fs", "fs"]) {
-			try {
-				const module = requireFn(specifier) as NodeFSModule | null
-				if (module && typeof module.readSync === "function" && typeof module.writeSync === "function") {
-					return module
-				}
-			} catch {
-				// Try the next fallback.
-			}
-		}
-	}
-
-	return null
+	return getHostRuntime().nodeFS
 }
 
 export function getDeno(): any | null {
-	return (globalThis as any).Deno ?? null
+	return getHostRuntime().deno
 }
 
 export function getPlatform(): string {
-	const denoObj = getDeno()
-	if (denoObj?.build?.os) {
-		return denoObj.build.os
-	}
-
-	const processObj = (globalThis as any).process
-	if (processObj?.platform) {
-		return processObj.platform
-	}
-
-	return "unknown"
+	return getHostRuntime().platform
 }
 
 export function getEnv(name: string): string {
-	const denoObj = getDeno()
-	if (denoObj?.env?.get) {
-		try {
-			return denoObj.env.get(name) ?? ""
-		} catch {
-			return ""
-		}
-	}
-
-	const processObj = (globalThis as any).process
-	return processObj?.env?.[name] ?? ""
+	return getHostRuntime().getEnv(name)
 }
 
 export function getDenoStream(fd: number): DenoStream | null {
-	const denoObj = getDeno()
-	if (!denoObj) {
-		return null
-	}
-
-	switch (fd) {
-		case 0:
-			return denoObj.stdin ?? null
-		case 1:
-			return denoObj.stdout ?? null
-		case 2:
-			return denoObj.stderr ?? null
-		default:
-			return null
-	}
+	return getHostRuntime().getStdioHandle(fd)
 }
 
 function readFD(fd: number, b: Uint8Array): [number, $.GoError] {
@@ -157,33 +57,18 @@ function readFD(fd: number, b: Uint8Array): [number, $.GoError] {
 		return [0, null]
 	}
 
-	const denoStream = getDenoStream(fd)
-	if (denoStream && typeof denoStream.readSync === "function") {
-		try {
-			const n = denoStream.readSync(b)
-			if (n === null || n === 0) {
-				return [0, io.EOF]
-			}
-			return [n, null]
-		} catch (err) {
-			return [0, newHostError(err)]
+	try {
+		const n = getHostRuntime().readFD(fd, b)
+		if (n === null || n === 0) {
+			return [0, io.EOF]
 		}
-	}
-
-	const nodeFS = getNodeFS()
-	if (nodeFS) {
-		try {
-			const n = nodeFS.readSync(fd, b, 0, b.length, null)
-			if (n === 0) {
-				return [0, io.EOF]
-			}
-			return [n, null]
-		} catch (err) {
-			return [0, newHostError(err)]
+		return [n, null]
+	} catch (err) {
+		if (err instanceof HostUnsupportedError) {
+			return [0, ErrUnimplemented]
 		}
+		return [0, newHostError(err)]
 	}
-
-	return [0, ErrUnimplemented]
 }
 
 function writeFD(fd: number, b: Uint8Array): [number, $.GoError] {
@@ -191,25 +76,51 @@ function writeFD(fd: number, b: Uint8Array): [number, $.GoError] {
 		return [0, null]
 	}
 
-	const denoStream = getDenoStream(fd)
-	if (denoStream && typeof denoStream.writeSync === "function") {
-		try {
-			return [denoStream.writeSync(b), null]
-		} catch (err) {
-			return [0, newHostError(err)]
+	try {
+		return [getHostRuntime().writeFD(fd, b), null]
+	} catch (err) {
+		if (err instanceof HostUnsupportedError) {
+			return [0, ErrUnimplemented]
 		}
+		return [0, newHostError(err)]
 	}
+}
 
-	const nodeFS = getNodeFS()
-	if (nodeFS) {
-		try {
-			return [nodeFS.writeSync(fd, b, 0, b.length, null), null]
-		} catch (err) {
-			return [0, newHostError(err)]
+function readHandle(handle: DenoFileLike, b: Uint8Array): [number, $.GoError] {
+	if (typeof handle.readSync !== "function") {
+		return [0, ErrUnimplemented]
+	}
+	try {
+		const n = handle.readSync(b)
+		if (n === null || n === 0) {
+			return [0, io.EOF]
 		}
+		return [n, null]
+	} catch (err) {
+		return [0, newHostError(err)]
 	}
+}
 
-	return [0, ErrUnimplemented]
+function writeHandle(handle: DenoFileLike, b: Uint8Array): [number, $.GoError] {
+	if (typeof handle.writeSync !== "function") {
+		return [0, ErrUnimplemented]
+	}
+	try {
+		let offset = 0
+		while (offset < b.length) {
+			const n = handle.writeSync(b.subarray(offset))
+			if (!Number.isFinite(n) || n < 0) {
+				throw new Error(`invalid write result: ${n}`)
+			}
+			if (n === 0) {
+				throw new Error("short write")
+			}
+			offset += n
+		}
+		return [b.length, null]
+	} catch (err) {
+		return [0, newHostError(err)]
+	}
 }
 
 class hostFileInfo {
@@ -281,11 +192,13 @@ export function createFileInfo(name: string, stat: HostStatLike): fs.FileInfo {
 export function createHostFile(name: string, fd: number = -1, handle: DenoFileLike | null = null): File {
 	return new File({
 		fd,
-		file: new file({ handle, path: name }),
+		file: new file({ handle: handle ?? getHostRuntime().getStdioHandle(fd), path: name }),
 		name,
 	})
 }
 
+export { resetHostRuntimeForTests }
+
 // Re-export essential types
 export type Time = time.Time;
 export type FileInfo = fs.FileInfo;
@@ -371,7 +284,11 @@ export class File {
 			return [0, null]
 		}
 		const buf = $.bytesToUint8Array(b)
-		const [n, err] = readFD(this.fd, buf)
+		const handle = this.file?.handle
+		const [n, err] =
+			handle && typeof handle.readSync === "function"
+				? readHandle(handle, buf)
+				: readFD(this.fd, buf)
 		if (!(b instanceof Uint8Array) && n > 0) {
 			$.copy(b, buf.subarray(0, n))
 		}
@@ -408,7 +325,11 @@ export class File {
 		if (b === null) {
 			return [0, null]
 		}
-		return writeFD(this.fd, $.bytesToUint8Array(b))
+		const buf = $.bytesToUint8Array(b)
+		const handle = this.file?.handle
+		return handle && typeof handle.writeSync === "function"
+			? writeHandle(handle, buf)
+			: writeFD(this.fd, buf)
 	}
 
 	public WriteAt(b: $.Bytes, off: number): [number, $.GoError] {

package/gs/reflect/index.ts

@@ -47,7 +47,6 @@ export {
 } from './types.js'
 export type {
   uintptr,
-  Pointer,
   Method,
   SelectDir,
   SliceHeader,
@@ -80,6 +79,7 @@ export {
   Interface,
   Map,
   Ptr,
+  Pointer,
   Slice,
   String,
   Struct,

package/gs/reflect/type.ts

@@ -167,6 +167,7 @@ export const Func: Kind = 19
 export const Interface: Kind = 20
 export const Map: Kind = 21
 export const Ptr: Kind = 22
+export const Pointer: Kind = Ptr
 export const Slice: Kind = 23
 export const String: Kind = 24
 export const Struct: Kind = 25
@@ -1945,22 +1946,7 @@ function getTypeOf(value: ReflectValue): Type {
           typeInfo.params &&
           typeInfo.results
         ) {
-          // Build proper function signature from type info
-          const paramTypes = typeInfo.params
-            .map((p: any) => (typeof p === 'string' ? p : p.name || 'any'))
-            .join(', ')
-          const resultTypes = typeInfo.results.map((r: any) =>
-            typeof r === 'string' ? r : r.name || 'any',
-          )
-
-          let signature = `func(${paramTypes})`
-          if (resultTypes.length === 1) {
-            signature += ` ${resultTypes[0]}`
-          } else if (resultTypes.length > 1) {
-            signature += ` (${resultTypes.join(', ')})`
-          }
-
-          return new FunctionType(signature)
+          return functionTypeFromInfo(typeInfo)
         }
       }
 
@@ -2180,10 +2166,113 @@ export function ChanOf(dir: ChanDir, t: Type): Type {
   return new ChannelType(t, dir)
 }
 
-export function TypeFor(): Type {
+export function TypeFor(typeArgs?: $.GenericTypeArgs): Type {
+  const descriptor = typeArgs?.T
+  if (descriptor?.type) {
+    return typeFromTypeInfo(descriptor.type)
+  }
+  if (descriptor?.methods) {
+    const methods = Object.keys(descriptor.methods)
+    if (methods.length !== 0) {
+      return new InterfaceType(
+        `interface { ${methods.map((method) => method + '()').join('; ')} }`,
+      )
+    }
+  }
+  if (descriptor?.zero) {
+    return getTypeOf(descriptor.zero())
+  }
   return new InterfaceType('interface{}')
 }
 
+function typeFromTypeInfo(info: $.TypeInfo | string): Type {
+  if (typeof info === 'string') {
+    const registered = builtinGetTypeByName(info)
+    if (registered) {
+      return typeFromTypeInfo(registered)
+    }
+    return StructType.createTypeFromFieldInfo(info)
+  }
+  switch (info.kind) {
+    case $.TypeKind.Array:
+      return new ArrayType(
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        info.length,
+      )
+    case $.TypeKind.Channel:
+      return new ChannelType(
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        chanDirFromTypeInfo(info.direction),
+      )
+    case $.TypeKind.Function:
+      return functionTypeFromInfo(info)
+    case $.TypeKind.Interface:
+      return interfaceTypeFromInfo(info)
+    case $.TypeKind.Map:
+      return new MapType(
+        typeFromTypeInfo(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+      )
+    case $.TypeKind.Pointer:
+      return new PointerType(
+        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+      )
+    default:
+      return StructType.createTypeFromFieldInfo(info)
+  }
+}
+
+function functionTypeFromInfo(info: $.FunctionTypeInfo): Type {
+  if (info.name) {
+    return new FunctionType(info.name)
+  }
+  const params = info.params ?? []
+  const paramTypes = params.map((param, index) => {
+    const typeName = functionSignatureTypeName(param)
+    if (!info.isVariadic || index !== params.length - 1) {
+      return typeName
+    }
+    if (typeName.startsWith('[]')) {
+      return '...' + typeName.slice(2)
+    }
+    return '...' + typeName
+  })
+  const resultTypes = (info.results ?? []).map(functionSignatureTypeName)
+  let signature = `func(${paramTypes.join(', ')})`
+  if (resultTypes.length === 1) {
+    signature += ` ${resultTypes[0]}`
+  }
+  if (resultTypes.length > 1) {
+    signature += ` (${resultTypes.join(', ')})`
+  }
+  return new FunctionType(signature)
+}
+
+function functionSignatureTypeName(info: $.TypeInfo | string): string {
+  return typeFromTypeInfo(info).String()
+}
+
+function interfaceTypeFromInfo(info: $.InterfaceTypeInfo): Type {
+  if (info.methods.length === 0) {
+    return new InterfaceType('interface{}', info.name)
+  }
+  return new InterfaceType(
+    `interface { ${info.methods.map((method) => method.name + '()').join('; ')} }`,
+    info.name,
+  )
+}
+
+function chanDirFromTypeInfo(direction?: 'send' | 'receive' | 'both'): ChanDir {
+  switch (direction) {
+    case 'send':
+      return SendDir
+    case 'receive':
+      return RecvDir
+    default:
+      return BothDir
+  }
+}
+
 /**
  * getInterfaceTypeByName looks up a registered interface type by name
  * and returns a Type for it. Returns an interface{} type if not found.