goscript 0.0.82 → 0.0.84

package/gs/os/file_unix_js.gs.ts

@@ -1,64 +1,238 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
-import { File } from "./types_js.gs.js";
+import { createFileInfo, createHostFile, File, getDeno, getEnv, getNodeFS, getPlatform, newHostError } from "./types_js.gs.js";
+import { O_APPEND, O_CREATE, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY } from "./file_constants_js.gs.js";
+import { FileInfoToDirEntry } from "@goscript/io/fs/readdir.js"
 
 import * as fs from "@goscript/io/fs/index.js"
 
-// JavaScript-specific implementations for Unix file operations
-// These functions stub Unix-specific operations that cannot be implemented in JavaScript
+function getDevNullPath(): string {
+	return getPlatform() === "win32" ? "NUL" : "/dev/null"
+}
+
+function getTempDirPath(): string {
+	for (const key of ["TMPDIR", "TEMP", "TMP"]) {
+		const value = getEnv(key)
+		if (value !== "") {
+			return value
+		}
+	}
+	return getPlatform() === "win32" ? "." : "/tmp"
+}
 
-// Device null path - stub for JavaScript
-export const DevNull = "/dev/null"
+function openOptionsFromFlags(flag: number): {
+	append: boolean
+	create: boolean
+	createNew: boolean
+	read: boolean
+	truncate: boolean
+	write: boolean
+} {
+	const readWrite = (flag & O_RDWR) !== 0
+	const writeOnly = !readWrite && (flag & O_WRONLY) !== 0
+	const write = readWrite || writeOnly
+	const read = readWrite || !writeOnly
+	return {
+		append: (flag & O_APPEND) !== 0,
+		create: (flag & O_CREATE) !== 0,
+		createNew: (flag & O_CREATE) !== 0 && (flag & O_EXCL) !== 0,
+		read,
+		truncate: (flag & O_TRUNC) !== 0,
+		write,
+	}
+}
 
-// Stdin, Stdout, Stderr - stub implementations
-export const Stdin: File | null = null
-export const Stdout: File | null = null  
-export const Stderr: File | null = null
+// Device null path for the host platform.
+export const DevNull = getDevNullPath()
 
-// NewFile creates a File from a file descriptor - stub implementation
+const standardInputFD = 0
+const standardOutputFD = 1
+const standardErrorFD = 2
+
+// Stdin, Stdout, and Stderr expose the host process standard streams.
+export const Stdin: File | null = NewFile(standardInputFD, "/dev/stdin")
+export const Stdout: File | null = NewFile(standardOutputFD, "/dev/stdout")
+export const Stderr: File | null = NewFile(standardErrorFD, "/dev/stderr")
+
+// NewFile creates a File from a file descriptor.
 export function NewFile(fd: number, name: string): File | null {
-	return null
+	if (!Number.isInteger(fd) || fd < 0) {
+		return null
+	}
+	return createHostFile(name, fd)
 }
 
-// File operations that need to be stubbed
 export function Remove(name: string): $.GoError {
+	const denoObj = getDeno()
+	if (denoObj?.removeSync) {
+		try {
+			denoObj.removeSync(name)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.rmSync) {
+		try {
+			nodeFS.rmSync(name)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	if (nodeFS?.unlinkSync) {
+		try {
+			nodeFS.unlinkSync(name)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
 export function Link(oldname: string, newname: string): $.GoError {
+	const denoObj = getDeno()
+	if (denoObj?.linkSync) {
+		try {
+			denoObj.linkSync(oldname, newname)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.linkSync) {
+		try {
+			nodeFS.linkSync(oldname, newname)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
 export function Symlink(oldname: string, newname: string): $.GoError {
+	const denoObj = getDeno()
+	if (denoObj?.symlinkSync) {
+		try {
+			denoObj.symlinkSync(oldname, newname)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.symlinkSync) {
+		try {
+			nodeFS.symlinkSync(oldname, newname)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
 export function Truncate(name: string, size: number): $.GoError {
+	const denoObj = getDeno()
+	if (denoObj?.truncateSync) {
+		try {
+			denoObj.truncateSync(name, size)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.truncateSync) {
+		try {
+			nodeFS.truncateSync(name, size)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
-// Internal stub functions that may be referenced by other files
 export function rename(oldname: string, newname: string): $.GoError {
+	const denoObj = getDeno()
+	if (denoObj?.renameSync) {
+		try {
+			denoObj.renameSync(oldname, newname)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.renameSync) {
+		try {
+			nodeFS.renameSync(oldname, newname)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
 export function openFileNolog(name: string, flag: number, perm: number): [File | null, $.GoError] {
+	const denoObj = getDeno()
+	if (denoObj?.openSync) {
+		try {
+			const handle = denoObj.openSync(name, {
+				...openOptionsFromFlags(flag),
+				mode: perm,
+			})
+			return [createHostFile(name, handle?.rid ?? -1, handle), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.openSync) {
+		try {
+			const fd = nodeFS.openSync(name, flag, perm)
+			return [createHostFile(name, fd), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
 	return [null, ErrUnimplemented]
 }
 
 export function openDirNolog(name: string): [File | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	return openFileNolog(name, O_RDONLY, 0)
 }
 
 export function tempDir(): string {
-	return "/tmp"
+	return getTempDirPath()
 }
 
 export function readlink(name: string): [string, $.GoError] {
+	const denoObj = getDeno()
+	if (denoObj?.readLinkSync) {
+		try {
+			return [denoObj.readLinkSync(name), null]
+		} catch (err) {
+			return ["", newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.readlinkSync) {
+		try {
+			return [nodeFS.readlinkSync(name), null]
+		} catch (err) {
+			return ["", newHostError(err)]
+		}
+	}
 	return ["", ErrUnimplemented]
 }
 
-// File class methods that need to be stubbed for unix compatibility
 export function fixLongPath(path: string): string {
 	return path
 }
@@ -71,24 +245,38 @@ export function epipecheck(file: File | null, e: $.GoError): void {
 	// No-op in JavaScript  
 }
 
-// dirInfo stub for compatibility
 export interface dirInfo {
 	close(): void
 }
 
-// Network file creation stub  
 export function net_newUnixFile(fd: number, name: string): File | null {
-	return null
+	return NewFile(fd, name)
 }
 
 // File kind enum for compatibility
 export type newFileKind = number
 
-export function newFile(fd: number, name: string, kind: newFileKind, nonBlocking: boolean): File | null {
-	return null
+export function newFile(fd: number, name: string, _kind: newFileKind, _nonBlocking: boolean): File | null {
+	return NewFile(fd, name)
 }
 
-// Directory entry stubs
-export function newUnixDirent(parent: string, name: string, typ: number): [fs.DirEntry | null, $.GoError] {
+export function newUnixDirent(parent: string, name: string, _typ: number): [fs.DirEntry | null, $.GoError] {
+	const fullName = parent === "" || parent === "." ? name : parent.replace(/\/+$/, "") + "/" + name
+	const denoObj = getDeno()
+	if (denoObj?.lstatSync) {
+		try {
+			return [FileInfoToDirEntry(createFileInfo(name, denoObj.lstatSync(fullName))), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.lstatSync) {
+		try {
+			return [FileInfoToDirEntry(createFileInfo(name, nodeFS.lstatSync(fullName))), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
 	return [null, ErrUnimplemented]
-} 
+} 

package/gs/os/file_unix_js.test.ts

@@ -0,0 +1,184 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import * as io from '@goscript/io/index.js'
+
+import { NewFile, Stderr, Stdin, Stdout } from './file_unix_js.gs.js'
+import { ErrClosed } from './error.gs.js'
+import { createHostFile, resetHostRuntimeForTests } from './types_js.gs.js'
+
+const originalDeno = (globalThis as any).Deno
+const originalProcess = (globalThis as any).process
+
+afterEach(() => {
+  if (originalDeno === undefined) {
+    delete (globalThis as any).Deno
+  } else {
+    ;(globalThis as any).Deno = originalDeno
+  }
+
+  if (originalProcess === undefined) {
+    delete (globalThis as any).process
+  } else {
+    ;(globalThis as any).process = originalProcess
+  }
+
+  resetHostRuntimeForTests()
+})
+
+describe('os stdio', () => {
+  it('exports standard file descriptors', () => {
+    expect(Stdin).not.toBeNull()
+    expect(Stdout).not.toBeNull()
+    expect(Stderr).not.toBeNull()
+    expect(Stdin!.Fd()).toBe(0)
+    expect(Stdout!.Fd()).toBe(1)
+    expect(Stderr!.Fd()).toBe(2)
+  })
+
+  it('uses Deno sync stdio when available', () => {
+    const stdoutWriteSync = vi.fn((buffer: Uint8Array) => buffer.length)
+    const stdinReadSync = vi.fn((buffer: Uint8Array) => {
+      buffer.set([1, 2, 3], 0)
+      return 3
+    })
+
+    ;(globalThis as any).Deno = {
+      stderr: { writeSync: vi.fn((buffer: Uint8Array) => buffer.length) },
+      stdin: { readSync: stdinReadSync },
+      stdout: { writeSync: stdoutWriteSync },
+    }
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    const input = NewFile(0, 'stdin')
+    const output = NewFile(1, 'stdout')
+    const readBuf = new Uint8Array(4)
+
+    const [readN, readErr] = input!.Read(readBuf)
+    expect(readN).toBe(3)
+    expect(readErr).toBeNull()
+    expect(Array.from(readBuf.slice(0, 3))).toEqual([1, 2, 3])
+
+    const writeBuf = new Uint8Array([4, 5, 6])
+    const [writeN, writeErr] = output!.Write(writeBuf)
+    expect(writeN).toBe(3)
+    expect(writeErr).toBeNull()
+    expect(stdoutWriteSync).toHaveBeenCalledTimes(1)
+    expect(stdoutWriteSync).toHaveBeenCalledWith(writeBuf)
+  })
+
+  it('uses process builtin fs sync stdio when Deno is unavailable', () => {
+    const readSync = vi.fn(
+      (
+        _fd: number,
+        buffer: Uint8Array,
+        _offset?: number,
+        _length?: number,
+        _position?: number | null,
+      ) => {
+        buffer.set([7, 8], 0)
+        return 2
+      },
+    )
+    const writeSync = vi.fn(
+      (
+        _fd: number,
+        _buffer: Uint8Array,
+        _offset?: number,
+        length?: number,
+        _position?: number | null,
+      ) => length ?? 0,
+    )
+
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync,
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    const input = NewFile(0, 'stdin')
+    const output = NewFile(1, 'stdout')
+    const readBuf = new Uint8Array(2)
+
+    const [readN, readErr] = input!.Read(readBuf)
+    expect(readN).toBe(2)
+    expect(readErr).toBeNull()
+    expect(Array.from(readBuf)).toEqual([7, 8])
+
+    const writeBuf = new Uint8Array([9, 10, 11, 12])
+    const [writeN, writeErr] = output!.Write(writeBuf)
+    expect(writeN).toBe(4)
+    expect(writeErr).toBeNull()
+    expect(writeSync).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns EOF on zero-byte reads and ErrClosed after Close', () => {
+    const stdinReadSync = vi.fn(() => 0)
+
+    ;(globalThis as any).Deno = {
+      stdin: { readSync: stdinReadSync },
+    }
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    const input = NewFile(0, 'stdin')!
+    const [readN, readErr] = input.Read(new Uint8Array(1))
+    expect(readN).toBe(0)
+    expect(readErr).toBe(io.EOF)
+
+    expect(input.Close()).toBeNull()
+    const [closedN, closedErr] = input.Read(new Uint8Array(1))
+    expect(closedN).toBe(0)
+    expect(closedErr).toBe(ErrClosed)
+  })
+
+  it('retries short writes until the full buffer is written', () => {
+    const writeSync = vi
+      .fn<(buffer: Uint8Array) => number>()
+      .mockImplementationOnce((_buffer: Uint8Array) => 2)
+      .mockImplementationOnce((buffer: Uint8Array) => buffer.length)
+
+    ;(globalThis as any).Deno = {
+      stdout: { writeSync },
+    }
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    const output = NewFile(1, 'stdout')!
+    const [writeN, writeErr] = output.Write(new Uint8Array([1, 2, 3, 4, 5]))
+    expect(writeN).toBe(5)
+    expect(writeErr).toBeNull()
+    expect(writeSync).toHaveBeenCalledTimes(2)
+    expect(Array.from(writeSync.mock.calls[1][0])).toEqual([3, 4, 5])
+  })
+
+  it('prefers direct handle read and write methods when available', () => {
+    const handle = {
+      readSync: vi.fn((buffer: Uint8Array) => {
+        buffer.set([11, 12, 13], 0)
+        return 3
+      }),
+      writeSync: vi
+        .fn<(buffer: Uint8Array) => number>()
+        .mockImplementationOnce((_buffer: Uint8Array) => 1)
+        .mockImplementationOnce((buffer: Uint8Array) => buffer.length),
+    }
+
+    const file = createHostFile('host-file', 99, handle)
+    const readBuf = new Uint8Array(4)
+
+    const [readN, readErr] = file.Read(readBuf)
+    expect(readN).toBe(3)
+    expect(readErr).toBeNull()
+    expect(Array.from(readBuf.slice(0, 3))).toEqual([11, 12, 13])
+
+    const [writeN, writeErr] = file.Write(new Uint8Array([21, 22, 23]))
+    expect(writeN).toBe(3)
+    expect(writeErr).toBeNull()
+    expect(handle.writeSync).toHaveBeenCalledTimes(2)
+    expect(Array.from(handle.writeSync.mock.calls[1][0])).toEqual([22, 23])
+  })
+})

package/gs/os/getwd_js.gs.ts

@@ -1,28 +1,38 @@
 import * as $ from "@goscript/builtin/index.js";
+import { getDeno } from "./types_js.gs.js";
 
 import * as fs from "@goscript/io/fs/index.js"
 
-// JavaScript-specific implementation of Getwd
-// Working directories are not a concept in JavaScript environments
-// Store working directory in a global variable
-
-// Global working directory variable, defaults to test directory
 let currentWorkingDir: string = "/"
 
 export function Getwd(): [string, $.GoError] {
+	const denoObj = getDeno()
+	if (denoObj?.cwd) {
+		try {
+			return [denoObj.cwd(), null]
+		} catch {
+			// Fall back to the tracked working directory below.
+		}
+	}
+	const processObj = (globalThis as any).process
+	if (processObj?.cwd) {
+		try {
+			return [processObj.cwd(), null]
+		} catch {
+			// Fall back to the tracked working directory below.
+		}
+	}
 	return [currentWorkingDir, null]
 }
 
-// Set the working directory (for internal use)
 export function setWorkingDir(dir: string): void {
 	currentWorkingDir = dir
 }
 
-// Additional functions that may be imported by other files
 export function statNolog(name: string): [fs.FileInfo | null, $.GoError] {
 	return [null, fs.ErrNotExist]
 }
 
 export function lstatNolog(name: string): [fs.FileInfo | null, $.GoError] {
 	return [null, fs.ErrNotExist]
-} 
+} 

package/gs/os/path.gs.ts

@@ -1,5 +1,5 @@
 import * as $ from "@goscript/builtin/index.js";
-import { ErrUnimplemented } from "./error.gs.js";
+import { MkdirAll as mkdirAllPath, RemoveAll as removeAllPath } from "./file_js.gs.js";
 import { IsPathSeparator } from "./path_unix.gs.js";
 
 // MkdirAll creates a directory named path,
@@ -10,7 +10,7 @@ import { IsPathSeparator } from "./path_unix.gs.js";
 // If path is already a directory, MkdirAll does nothing
 // and returns nil.
 export function MkdirAll(path: string, perm: number): $.GoError {
-	return ErrUnimplemented
+	return mkdirAllPath(path, perm)
 }
 
 // RemoveAll removes path and any children it contains.
@@ -19,7 +19,7 @@ export function MkdirAll(path: string, perm: number): $.GoError {
 // returns nil (no error).
 // If there is an error, it will be of type [*PathError].
 export function RemoveAll(path: string): $.GoError {
-	return ErrUnimplemented
+	return removeAllPath(path)
 }
 
 // endsWithDot reports whether the final component of path is ".".
@@ -32,4 +32,3 @@ export function endsWithDot(path: string): boolean {
 	}
 	return false
 }
-

package/gs/os/pidfd_js.gs.ts

@@ -1,25 +1,20 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
 
-// JavaScript-specific stubs for pidfd operations
-// These operations are Linux-specific and not available in JavaScript
+// JavaScript runtimes do not expose Linux pidfd operations.
 
-// SysProcAttr stub for compatibility
 export interface SysProcAttr {
-	// Stub interface for process attributes
+	// Process attributes are not modeled for JavaScript pidfd support.
 }
 
-// ensurePidfd ensures pidfd support - stub implementation
 export function ensurePidfd(sysAttr: SysProcAttr | null): [SysProcAttr | null, boolean] {
 	return [null, false]
 }
 
-// getPidfd gets a process file descriptor - stub implementation  
 export function getPidfd(_: SysProcAttr | null, _usePidfd: boolean): [number, boolean] {
 	return [0, false]
 }
 
-// pidfdFind finds a process by pidfd - stub implementation
 export function pidfdFind(_: number): [number, $.GoError] {
 	return [0, ErrUnimplemented]
-} 
+}

package/gs/os/proc.gs.ts

@@ -1,5 +1,6 @@
 import * as $ from "@goscript/builtin/index.js";
 import { NewSyscallError, ErrUnimplemented } from "./error.gs.js";
+import { runtime_args as hostRuntimeArgs, runtime_beforeExit as hostRuntimeBeforeExit } from "./proc_js.gs.js";
 
 import * as runtime from "@goscript/runtime/index.js"
 
@@ -13,7 +14,7 @@ export function init(): void {
 }
 
 export function runtime_args(): $.Slice<string> {
-	return $.arrayToSlice<string>([])
+	return hostRuntimeArgs()
 }
 
 // Getuid returns the numeric user id of the caller.
@@ -59,7 +60,7 @@ export function Getgroups(): [$.Slice<number>, $.GoError] {
 // For portability, the status code should be in the range [0, 125].
 export function Exit(code: number): void {
 
-	// Testlog functionality not available in JavaScript - stub
+	// Testlog functionality is not available in JavaScript.
 	// if (code == 0 && testlog.PanicOnExit0()) {
 	//	$.panic("unexpected call to os.Exit(0) during test")
 	// }
@@ -80,5 +81,6 @@ export function Exit(code: number): void {
 	}
 }
 
-export function runtime_beforeExit(exitCode: number): void {}
-
+export function runtime_beforeExit(exitCode: number): void {
+	hostRuntimeBeforeExit(exitCode)
+}

package/gs/os/proc_js.gs.ts

@@ -1,15 +1,18 @@
 import * as $ from "@goscript/builtin/index.js";
-import { ErrUnimplemented } from "./error.gs.js";
+import { getDeno } from "./types_js.gs.js";
 
-// JavaScript-specific process functions
-
-// runtime_args returns command line arguments (stub for JS)
 export function runtime_args(): $.Slice<string> {
-	// In JavaScript environment, return empty args or process.argv equivalent
+	const denoObj = getDeno()
+	if (Array.isArray(denoObj?.args)) {
+		return $.arrayToSlice<string>(denoObj.args)
+	}
+	const processObj = (globalThis as any).process
+	if (Array.isArray(processObj?.argv)) {
+		return $.arrayToSlice<string>(processObj.argv.slice(2))
+	}
 	return $.arrayToSlice<string>([])
 }
 
-// runtime_beforeExit is called before exit (stub for JS)
 export function runtime_beforeExit(exitCode: number): void {
-	// No-op in JavaScript
-} 
+	// No-op in JavaScript.
+}