goscript 0.0.81 → 0.0.83

package/gs/os/dir.gs.ts

@@ -1,42 +1,54 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
+import { createFileInfo, getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
+import { FileInfoToDirEntry } from "@goscript/io/fs/readdir.js";
 
 import * as fs from "@goscript/io/fs/index.js"
 
 type DirEntry = fs.DirEntry;
 
-// ReadDir reads the named directory,
-// returning all its directory entries sorted by filename.
-// If an error occurs reading the directory,
-// ReadDir returns the entries it was able to read before the error,
-// along with the error.
 export function ReadDir(name: string): [$.Slice<DirEntry>, $.GoError] {
-	// Directory reading not supported in JavaScript environment
+	const denoObj = getDeno()
+	if (denoObj?.readDirSync) {
+		try {
+			const entries: DirEntry[] = []
+			for (const entry of denoObj.readDirSync(name)) {
+				const dirEntry = FileInfoToDirEntry(createFileInfo(entry.name, {
+					isDirectory: () => entry.isDirectory,
+					isSymbolicLink: () => entry.isSymlink,
+					mode: 0,
+					size: 0,
+				}))
+				if (dirEntry !== null) {
+					entries.push(dirEntry)
+				}
+			}
+			entries.sort((a, b) => (a?.Name() ?? "").localeCompare(b?.Name() ?? ""))
+			return [$.arrayToSlice(entries), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.readdirSync) {
+		try {
+			const entries = nodeFS.readdirSync(name, { withFileTypes: true }).map((entry: any) =>
+				FileInfoToDirEntry(createFileInfo(entry.name, {
+					isDirectory: () => typeof entry.isDirectory === "function" ? entry.isDirectory() : false,
+					isSymbolicLink: () => typeof entry.isSymbolicLink === "function" ? entry.isSymbolicLink() : false,
+					mode: 0,
+					size: 0,
+				}))
+			).filter((entry: DirEntry | null): entry is DirEntry => entry !== null)
+			entries.sort((a, b) => (a?.Name() ?? "").localeCompare(b?.Name() ?? ""))
+			return [$.arrayToSlice(entries), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
 	return [null, ErrUnimplemented]
 }
 
-// CopyFS copies the file system fsys into the directory dir,
-// creating dir if necessary.
-//
-// Files are created with mode 0o666 plus any execute permissions
-// from the source, and directories are created with mode 0o777
-// (before umask).
-//
-// CopyFS will not overwrite existing files. If a file name in fsys
-// already exists in the destination, CopyFS will return an error
-// such that errors.Is(err, fs.ErrExist) will be true.
-//
-// Symbolic links in fsys are not supported. A *PathError with Err set
-// to ErrInvalid is returned when copying from a symbolic link.
-//
-// Symbolic links in dir are followed.
-//
-// New files added to fsys (including if dir is a subdirectory of fsys)
-// while CopyFS is running are not guaranteed to be copied.
-//
-// Copying stops at and returns the first error encountered.
 export function CopyFS(dir: string, fsys: fs.FS): $.GoError {
-	// File system copying not supported in JavaScript environment
 	return ErrUnimplemented
 }
-

package/gs/os/exec.gs.ts

@@ -137,7 +137,7 @@ export class ProcAttr {
 	);
 }
 
-// Stub ProcessState for JavaScript environment
+// ProcessState mirrors the minimal JavaScript process surface.
 export class ProcessState {
 	public _fields: {}
 
@@ -159,14 +159,13 @@ export class ProcessState {
 	);
 }
 
-// Signal interface stub
+// Signal matches the Go signal interface shape when available.
 export type Signal = null | {
 	Signal(): void
 	String(): string
 }
 export const Signal = null as any;
 
-// Stub functions that return ErrUnimplemented
 export function Getpid(): number {
 	return -1 // Not available in JavaScript
 }
@@ -195,4 +194,3 @@ export function newHandleProcess(pid: number, handle: number): Process {
 export function newPIDProcess(pid: number): Process {
 	return new Process({Pid: pid})
 }
-

package/gs/os/exec_posix.gs.ts

@@ -36,7 +36,7 @@ export class ProcessState {
 		return cloned
 	}
 
-	// All methods return stub values for JavaScript environment
+	// JavaScript does not expose process timing and wait status details.
 	public UserTime(): any {
 		return 0 // Duration not available
 	}
@@ -92,4 +92,3 @@ export class ProcessState {
 		{ "pid": { kind: $.TypeKind.Basic, name: "number" } }
 	);
 }
-

package/gs/os/file_constants_js.gs.ts

@@ -1,8 +1,16 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
+import { getDeno, getEnv, getNodeFS, getPlatform, newHostError } from "./types_js.gs.js";
 
-// JavaScript-specific stubs for file constants and operations
-// These provide the required constants and stub implementations
+function pickFirstEnv(keys: string[]): string {
+	for (const key of keys) {
+		const value = getEnv(key)
+		if (value !== "") {
+			return value
+		}
+	}
+	return ""
+}
 
 // File open flags - using values compatible with typical Unix systems
 export const O_RDONLY = 0
@@ -19,7 +27,7 @@ export const SEEK_SET = 0
 export const SEEK_CUR = 1
 export const SEEK_END = 2
 
-// LinkError stub for compatibility
+// LinkError carries details for link-related path errors.
 export class LinkError {
 	public get Op(): string {
 		return this._fields.Op.value
@@ -76,23 +84,77 @@ export class LinkError {
 	}
 }
 
-// Directory and file operation stubs
 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]
 }
 
 export function TempDir(): string {
-	return "/tmp"
+	const value = pickFirstEnv(["TMPDIR", "TEMP", "TMP"])
+	if (value !== "") {
+		return value
+	}
+	return getPlatform() === "win32" ? "." : "/tmp"
 }
 
 export function UserCacheDir(): [string, $.GoError] {
-	return ["", ErrUnimplemented]
+	if (getPlatform() === "win32") {
+		const value = pickFirstEnv(["LOCALAPPDATA", "APPDATA", "USERPROFILE"])
+		if (value !== "") {
+			return [value, null]
+		}
+		return ["", ErrUnimplemented]
+	}
+	const value = pickFirstEnv(["XDG_CACHE_HOME"])
+	if (value !== "") {
+		return [value, null]
+	}
+	const [home, err] = UserHomeDir()
+	if (err !== null || home === "") {
+		return ["", err ?? ErrUnimplemented]
+	}
+	return [home.replace(/\/+$/, "") + "/.cache", null]
 }
 
 export function UserConfigDir(): [string, $.GoError] {
-	return ["", ErrUnimplemented]
+	if (getPlatform() === "win32") {
+		const value = pickFirstEnv(["APPDATA", "USERPROFILE"])
+		if (value !== "") {
+			return [value, null]
+		}
+		return ["", ErrUnimplemented]
+	}
+	const value = pickFirstEnv(["XDG_CONFIG_HOME"])
+	if (value !== "") {
+		return [value, null]
+	}
+	const [home, err] = UserHomeDir()
+	if (err !== null || home === "") {
+		return ["", err ?? ErrUnimplemented]
+	}
+	return [home.replace(/\/+$/, "") + "/.config", null]
 }
 
 export function UserHomeDir(): [string, $.GoError] {
+	const keys = getPlatform() === "win32" ? ["USERPROFILE", "HOMEDRIVE", "HOME"] : ["HOME"]
+	const value = pickFirstEnv(keys)
+	if (value !== "") {
+		return [value, null]
+	}
 	return ["", ErrUnimplemented]
-} 
+}

package/gs/os/file_js.gs.ts

@@ -1,99 +1,229 @@
 import * as $ from "@goscript/builtin/index.js";
-import { ErrUnimplemented } from "./error.gs.js";
+import { ErrInvalid, ErrUnimplemented } from "./error.gs.js";
 import { File } from "./types_js.gs.js";
+import { getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
+import { O_CREATE, O_RDONLY, O_RDWR, O_TRUNC } from "./file_constants_js.gs.js";
+import { Link as linkPath, openFileNolog, readlink, Remove as removePath, rename as renamePath, Symlink as symlinkPath, Truncate as truncatePath } from "./file_unix_js.gs.js";
+import { Lstat as lstatPath, Stat as statPath } from "./stat_js.gs.js";
+import { ValidPath } from "@goscript/io/fs/index.js"
 
 import * as fs from "@goscript/io/fs/index.js"
 
-// JavaScript-specific implementations for filesystem operations
-// These functions stub filesystem operations that cannot be implemented 
-// in a JavaScript environment
-
-// File operations - stub implementations
 export function Open(name: string): [File | null, $.GoError] {
-  return [null, ErrUnimplemented]
+  return OpenFile(name, O_RDONLY, 0)
 }
 
 export function Create(name: string): [File | null, $.GoError] {
-  return [null, ErrUnimplemented]
+  return OpenFile(name, O_RDWR | O_CREATE | O_TRUNC, 0o666)
 }
 
 export function OpenFile(name: string, flag: number, perm: number): [File | null, $.GoError] {
-  return [null, ErrUnimplemented]
+  return openFileNolog(name, flag, perm)
 }
 
 export function ReadFile(name: string): [$.Bytes, $.GoError] {
+  const denoObj = getDeno()
+  if (denoObj?.readFileSync) {
+    try {
+      return [denoObj.readFileSync(name), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
+  const nodeFS = getNodeFS()
+  if (nodeFS?.readFileSync) {
+    try {
+      return [nodeFS.readFileSync(name), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
   return [null, ErrUnimplemented]
 }
 
 export function WriteFile(name: string, data: $.Bytes, perm: number): $.GoError {
+  const buf = $.bytesToUint8Array(data)
+  const denoObj = getDeno()
+  if (denoObj?.writeFileSync) {
+    try {
+      denoObj.writeFileSync(name, buf, { mode: perm })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
+  const nodeFS = getNodeFS()
+  if (nodeFS?.writeFileSync) {
+    try {
+      nodeFS.writeFileSync(name, buf, { mode: perm })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
   return ErrUnimplemented
 }
 
-// Directory operations - stub implementations  
 export function Mkdir(name: string, perm: number): $.GoError {
+  const denoObj = getDeno()
+  if (denoObj?.mkdirSync) {
+    try {
+      denoObj.mkdirSync(name, { mode: perm })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
+  const nodeFS = getNodeFS()
+  if (nodeFS?.mkdirSync) {
+    try {
+      nodeFS.mkdirSync(name, { mode: perm })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
   return ErrUnimplemented
 }
 
 export function MkdirAll(path: string, perm: number): $.GoError {
+  const denoObj = getDeno()
+  if (denoObj?.mkdirSync) {
+    try {
+      denoObj.mkdirSync(path, { mode: perm, recursive: true })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
+  const nodeFS = getNodeFS()
+  if (nodeFS?.mkdirSync) {
+    try {
+      nodeFS.mkdirSync(path, { mode: perm, recursive: true })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
   return ErrUnimplemented
 }
 
 export function Remove(name: string): $.GoError {
-  return ErrUnimplemented
+  return removePath(name)
 }
 
 export function RemoveAll(path: string): $.GoError {
+  const denoObj = getDeno()
+  if (denoObj?.removeSync) {
+    try {
+      denoObj.removeSync(path, { recursive: true })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
+  const nodeFS = getNodeFS()
+  if (nodeFS?.rmSync) {
+    try {
+      nodeFS.rmSync(path, { force: true, recursive: true })
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
   return ErrUnimplemented
 }
 
 export function Chdir(dir: string): $.GoError {
+  const denoObj = getDeno()
+  if (denoObj?.chdir) {
+    try {
+      denoObj.chdir(dir)
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
+  const processObj = (globalThis as any).process
+  if (processObj?.chdir) {
+    try {
+      processObj.chdir(dir)
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
   return ErrUnimplemented
 }
 
 export function Chmod(name: string, mode: number): $.GoError {
+  const denoObj = getDeno()
+  if (denoObj?.chmodSync) {
+    try {
+      denoObj.chmodSync(name, mode)
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
+  const nodeFS = getNodeFS()
+  if (nodeFS?.chmodSync) {
+    try {
+      nodeFS.chmodSync(name, mode)
+      return null
+    } catch (err) {
+      return newHostError(err)
+    }
+  }
   return ErrUnimplemented
 }
 
 export function Rename(oldpath: string, newpath: string): $.GoError {
-  return ErrUnimplemented
+  return renamePath(oldpath, newpath)
 }
 
-// File information operations - stub implementations
 export function Stat(name: string): [fs.FileInfo, $.GoError] {
-  return [null, ErrUnimplemented]
+  return statPath(name)
 }
 
 export function Lstat(name: string): [fs.FileInfo, $.GoError] {
-  return [null, ErrUnimplemented]
+  return lstatPath(name)
 }
 
-// Link operations - stub implementations  
 export function Link(oldname: string, newname: string): $.GoError {
-  return ErrUnimplemented
+  return linkPath(oldname, newname)
 }
 
 export function Symlink(oldname: string, newname: string): $.GoError {
-  return ErrUnimplemented
+  return symlinkPath(oldname, newname)
 }
 
 export function Readlink(name: string): [string, $.GoError] {
-  return ["", ErrUnimplemented]
+  return readlink(name)
 }
 
 export function Truncate(name: string, size: number): $.GoError {
-  return ErrUnimplemented
+  return truncatePath(name, size)
 }
 
-// File system information - stub implementations
 export function DirFS(dir: string): fs.FS {
-  // Return a stub filesystem that always returns ErrUnimplemented
-  return new stubFS()
+  return new hostFS({ root: dir })
 }
 
-class stubFS {
+class hostFS {
+  public root: string
+
+  constructor(init?: Partial<{ root?: string }>) {
+    this.root = init?.root ?? "."
+  }
+
   public Open(name: string): [fs.File, $.GoError] {
-    return [null, ErrUnimplemented]
+    if (!ValidPath(name)) {
+      return [null, ErrInvalid]
+    }
+    const fullPath = name === "." ? this.root : this.root.replace(/\/+$/, "") + "/" + name
+    return Open(fullPath)
   }
 }
 
- 
+ 

package/gs/os/file_posix_js.gs.ts

@@ -1,40 +1,96 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
+import { getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
 
-// JavaScript-specific stubs for POSIX file operations
-// These operations are not available in JavaScript environments
-
-// syscallMode stub
 export function syscallMode(i: number): number {
 	return 0
 }
 
-// ignoringEINTR stub
 export function ignoringEINTR(fn: () => $.GoError): $.GoError {
-	return ErrUnimplemented
+	return fn()
 }
 
-// ignoringEINTR2 stub
 export function ignoringEINTR2(fn: () => [string, $.GoError]): [string, $.GoError] {
-	return ["", ErrUnimplemented]
+	return fn()
 }
 
-// Chmod operation stub
 export function Chmod(name: string, mode: number): $.GoError {
+	const denoObj = getDeno()
+	if (denoObj?.chmodSync) {
+		try {
+			denoObj.chmodSync(name, mode)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.chmodSync) {
+		try {
+			nodeFS.chmodSync(name, mode)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
-// Chown operation stub
 export function Chown(name: string, uid: number, gid: number): $.GoError {
+	const denoObj = getDeno()
+	if (denoObj?.chownSync) {
+		try {
+			denoObj.chownSync(name, uid, gid)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.chownSync) {
+		try {
+			nodeFS.chownSync(name, uid, gid)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
-// Lchown operation stub
 export function Lchown(name: string, uid: number, gid: number): $.GoError {
+	const nodeFS = getNodeFS()
+	if (nodeFS?.lchownSync) {
+		try {
+			nodeFS.lchownSync(name, uid, gid)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
 }
 
-// Chtimes operation stub
 export function Chtimes(name: string, atime: any, mtime: any): $.GoError {
+	const at = typeof atime?.UnixMilli === "function" ? new Date(atime.UnixMilli()) : new Date(atime)
+	const mt = typeof mtime?.UnixMilli === "function" ? new Date(mtime.UnixMilli()) : new Date(mtime)
+	const denoObj = getDeno()
+	if (denoObj?.utimeSync) {
+		try {
+			denoObj.utimeSync(name, at, mt)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.utimesSync) {
+		try {
+			nodeFS.utimesSync(name, at, mt)
+			return null
+		} catch (err) {
+			return newHostError(err)
+		}
+	}
 	return ErrUnimplemented
-} 
+}