lixen/chess
SHA256
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.8.0 wasm client added, cli client and makefile updated

Browse Source
This commit is contained in:
Lixen Wraith
2025-11-14 05:57:37 -05:00
parent 2a2e82a162
commit ef60cfaac5
22 changed files with 1073 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -5,4 +5,4 @@ bin
db
build.sh
.chess_history
*.wasm

60
Makefile
View File

@ -3,10 +3,11 @@
# Variables
BINARY_DIR := bin
SERVER_BINARY := $(BINARY_DIR)/chess-server
CLIENT_BINARY := $(BINARY_DIR)/chess-client
CLIENT_BINARY := $(BINARY_DIR)/chess-client-cli
SERVER_SOURCE := ./cmd/chess-server
CLIENT_SOURCE := ./cmd/chess-client
CLIENT_SOURCE := ./cmd/chess-client-cli
GO := go
GOROOT := $(shell go env GOROOT)
GOFLAGS := -trimpath
LDFLAGS := -s -w
@ -15,6 +16,12 @@ GIT_COMMIT := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
BUILD_TIME := $(shell date -u '+%Y-%m-%d_%H:%M:%S')
VERSION := $(shell git describe --tags --abbrev=0 2>/dev/null || echo "dev")
# WASM build variables
WASM_DIR := web/chess-client-wasm
WASM_BINARY := $(WASM_DIR)/chess-client.wasm
WASM_EXEC_JS := $(WASM_DIR)/wasm_exec.js
WASM_EXEC_SRC := $(GOROOT)/lib/wasm/wasm_exec.js
# Default target
.PHONY: all
all: build
@ -43,6 +50,48 @@ $(CLIENT_BINARY): $(BINARY_DIR)
$(BINARY_DIR):
@mkdir -p $(BINARY_DIR)
# Build WASM client
.PHONY: wasm
wasm: $(WASM_DIR)
@echo "Building WASM client..."
GOOS=js GOARCH=wasm $(GO) build $(GOFLAGS) \
-ldflags "$(LDFLAGS)" \
-o $(WASM_BINARY) $(CLIENT_SOURCE)
@cp "$(WASM_EXEC_SRC)" $(WASM_DIR)/
@echo "Built WASM client: $(WASM_BINARY)"
@echo "Size: $$(du -h $(WASM_BINARY) | cut -f1)"
# Download xterm.js dependencies
.PHONY: wasm-deps
wasm-deps: $(WASM_DIR)
@echo "Downloading xterm.js 5.5.0..."
@mkdir -p $(WASM_DIR)/lib
@cd $(WASM_DIR)/lib && \
curl -sO https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/lib/xterm.min.js && \
curl -sO https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/css/xterm.css
@echo "xterm.js 5.5.0 downloaded to $(WASM_DIR)/lib/"
# Build WASM with dependencies
.PHONY: wasm-full
wasm-full: wasm-deps wasm
# Serve WASM client for testing
.PHONY: wasm-serve
wasm-serve: wasm
@echo "Starting WASM server on http://localhost:8081"
@echo "Open http://localhost:8081 in your browser"
cd $(WASM_DIR) && python3 -m http.server 8081 --bind 127.0.0.1
# Clean WASM build
.PHONY: wasm-clean
wasm-clean:
rm -f $(WASM_BINARY) $(WASM_EXEC_JS)
rm -rf $(WASM_DIR)/lib
# Create WASM directory
$(WASM_DIR):
@mkdir -p $(WASM_DIR)
# Run server with default settings
.PHONY: run-server
run-server: server
@ -131,12 +180,15 @@ help:
@echo " make build Build both server and client"
@echo " make server Build server only"
@echo " make client Build client only"
@echo " make wasm Build WASM client"
@echo " make wasm-full Build WASM with dependencies"
@echo " make dev Build with race detector"
@echo ""
@echo "Run targets:"
@echo " make run-server Run server (port 8080, dev mode)"
@echo " make run-server-web Run server with web UI (ports 8080/9090)"
@echo " make run-client Run client"
@echo " make wasm-serve Serve WASM client (port 8081)"
@echo ""
@echo "Test targets:"
@echo " make test Run all tests"
@ -148,6 +200,10 @@ help:
@echo " make db-init Initialize database"
@echo " make db-clean Remove database (destructive)"
@echo ""
@echo "WASM targets:"
@echo " make wasm-deps Download xterm.js dependencies"
@echo " make wasm-clean Clean WASM build files"
@echo ""
@echo "Maintenance:"
@echo " make clean Remove build artifacts"
@echo " make deps Download dependencies"

9
README.md
View File

@ -1,10 +1,10 @@
<table>
<tr>
<td>
<h1>Go Chess API</h1>
<h1>♚♛♜♝♞</h1>
<p>
<a href="https://golang.org"><img src="https://img.shields.io/badge/Go-1.25-00ADD8?style=flat&logo=go" alt="Go"></a>
<a href="https://opensource.org/licenses/BSD-3-Clause"><img src="https://img.shields.io/badge/License-BSD_3--Clause-blue.svg" alt="License"></a>
<a href="https://golang.org"><img src="https://img.shields.io/badge/Go-1.25-00ADD8?style=flat&logo=go" alt="Go 1.25"></a>
<a href="https://opensource.org/licenses/BSD-3-Clause"><img src="https://img.shields.io/badge/License-BSD_3--Clause-blue.svg" alt="License BSD-3"></a>
</p>
</td>
</tr>
@ -60,6 +60,9 @@ make run-server-web
# Initialize database with user support
make db-init
# View all build options
make help
# Add users via CLI
./bin/chess-server db user add -path db/chess.db -username alice -password AlicePass123
```

13
cmd/chess-client-cli/exit_native.go Normal file
View File

@ -0,0 +1,13 @@
// FILE: lixenwraith/chess/cmd/chess-client-cli/exit_native.go
//go:build !js && !wasm
package main
import (
"chess/internal/client/display"
)
func handleExit() (restart bool) {
display.Println(display.Cyan, "Goodbye!")
return false
}

19
cmd/chess-client-cli/exit_wasm.go Normal file
View File

@ -0,0 +1,19 @@
// FILE: lixenwraith/chess/cmd/chess-client-cli/exit_wasm.go
//go:build js && wasm
package main
import (
"chess/internal/client/display"
)
func handleExit() (restart bool) {
display.Println(display.Cyan, "Goodbye!")
display.Println(display.Yellow, "\n━━━━━━━━━━━━━━━━━━━━━━━━")
display.Println(display.Yellow, "Session ended.")
display.Println(display.Yellow, "Restarting the client.")
display.Println(display.Yellow, "━━━━━━━━━━━━━━━━━━━━━━━━\n")
return true
}

24
cmd/chess-client/main.go → cmd/chess-client-cli/main.go
View File

@ -1,5 +1,5 @@
// FILE: lixenwraith/chess/cmd/chess-client/main.go
// Package main implements an interactive debugging client for the chess server API.
// FILE: lixenwraith/chess/cmd/chess-client-cli/main.go
// Package main implements an interactive cli debugging client for the chess server API.
package main
import (
@ -15,6 +15,21 @@ import (
)
func main() {
for {
if !runClient() {
break
}
}
}
func runClient() (restart bool) {
defer func() {
if r := recover(); r != nil {
display.Println(display.Red, "Client crashed: %v", r)
panic(r)
}
}()
s := &session.Session{
APIBaseURL: "http://localhost:8080",
Client: api.New("http://localhost:8080"),
@ -51,8 +66,7 @@ func main() {
// Check for exit commands
if line == "exit" || line == "quit" || line == "x" {
display.Println(display.Cyan, "Goodbye!")
break
return handleExit()
}
// Check for verbose flag
@ -65,6 +79,8 @@ func main() {
registry.Execute(line)
}
return false
}
func buildPrompt(s *session.Session) string {

8
doc/client.md
View File

@ -1,4 +1,4 @@
# Chess Client Documentation
# Chess CLI Client Documentation
The chess client is an interactive command-line debugging tool for the chess server API. It provides a rich terminal interface with colored output, command completion, and session management.
@ -14,13 +14,15 @@ The chess client is an interactive command-line debugging tool for the chess ser
## Building
```bash
go build ./cmd/chess-client
go build ./cmd/chess-client-cli
# or with make: make build client
```
## Running
```bash
# Connect to default server (localhost:8080)
./chess-client
./chess-client-cli
# if built with make: bin/chess-client-cli
# The client starts with an interactive prompt
chess >

18
internal/client/command/debug.go
View File

@ -3,8 +3,6 @@ package command
import (
"fmt"
"os"
"os/exec"
"strings"
"time"
@ -37,14 +35,6 @@ func (r *Registry) registerDebugCommands() {
Usage: "raw <method> <path> [json-body]",
Handler: rawRequestHandler,
})
r.Register(&Command{
Name: "clear",
ShortName: "-",
Description: "Clear screen",
Usage: "clear",
Handler: clearHandler,
})
}
func healthHandler(s *session.Session, args []string) error {
@ -54,7 +44,7 @@ func healthHandler(s *session.Session, args []string) error {
return err
}
display.Println(display.Cyan, "%sServer Health:%s")
display.Println(display.Cyan, "Server Health:")
fmt.Printf(" Status: %s\n", resp.Status)
// Convert Unix timestamp to readable time
t := time.Unix(resp.Time, 0)
@ -100,10 +90,4 @@ func rawRequestHandler(s *session.Session, args []string) error {
c := s.GetClient().(*api.Client)
return c.RawRequest(method, path, body)
}
func clearHandler(s *session.Session, args []string) error {
cmd := exec.Command("clear")
cmd.Stdout = os.Stdout
return cmd.Run()
}

2
internal/client/command/pass_unix.go → internal/client/command/pass_native.go
View File

@ -1,4 +1,4 @@
// FILE: internal/client/command/auth_unix.go
// FILE: lixenwraith/chess/internal/client/command/pass_native.go
//go:build !js && !wasm
package command

2
internal/client/command/pass_wasm.go
View File

@ -1,4 +1,4 @@
// FILE: lixenwraith/chess/internal/client/command/auth_wasm.go
// FILE: lixenwraith/chess/internal/client/command/pass_wasm.go
//go:build js && wasm
package command

1
internal/client/command/registry.go
View File

@ -141,7 +141,6 @@ func (r *Registry) helpHandler(s *session.Session, args []string) error {
{"health", ".", ""},
{"url", "/", ""},
{"raw", ":", ""},
{"clear", "-", ""},
{"help", "?", ""},
{"exit", "x", ""},
}

0
internal/server/webserver/web/app.js → internal/server/webserver/chess-client-web/app.js
View File

0
internal/server/webserver/web/index.html → internal/server/webserver/chess-client-web/index.html
View File

0
internal/server/webserver/web/style.css → internal/server/webserver/chess-client-web/style.css
View File

6
internal/server/webserver/server.go
View File

@ -13,7 +13,7 @@ import (
"github.com/gofiber/fiber/v2/middleware/logger"
)
//go:embed web
//go:embed chess-client-web
var webFS embed.FS
// Start initializes and starts the web UI server
@ -58,8 +58,8 @@ func Start(host string, port int, apiURL string) error {
// Try to read the file
data, err := fs.ReadFile(webContent, fsPath)
if err != nil {
// If the file isn't found, serve index.html for SPA-style routing.
// This handles client-side routes that don't correspond to a file.
// If the file isn't found, serve index.html for SPA-style routing
// This handles client-side routes that don't correspond to a file
data, err = fs.ReadFile(webContent, "index.html")
if err != nil {
return c.Status(fiber.StatusInternalServerError).SendString("index.html not found")

16
web/chess-client-wasm/index.html Normal file
View File

@ -0,0 +1,16 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Chess Client Terminal</title>
<link rel="icon" href="data:,"> <!-- Prevents favicon request -->
<link rel="stylesheet" href="lib/xterm.css">
<link rel="stylesheet" href="terminal.css">
</head>
<body>
<div id="terminal"></div>
<script src="lib/xterm.min.js"></script>
<script src="wasm_exec.js"></script>
<script src="terminal.js"></script>
</body>
</html>

218
web/chess-client-wasm/lib/xterm.css Normal file
View File

@ -0,0 +1,218 @@
/**
* Copyright (c) 2014 The xterm.js authors. All rights reserved.
* Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
* https://github.com/chjj/term.js
* @license MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* Originally forked from (with the author's permission):
* Fabrice Bellard's javascript vt100 for jslinux:
* http://bellard.org/jslinux/
* Copyright (c) 2011 Fabrice Bellard
* The original design remains. The terminal itself
* has been extended to include xterm CSI codes, among
* other features.
*/
/**
* Default styles for xterm.js
*/
.xterm {
cursor: text;
position: relative;
user-select: none;
-ms-user-select: none;
-webkit-user-select: none;
}
.xterm.focus,
.xterm:focus {
outline: none;
}
.xterm .xterm-helpers {
position: absolute;
top: 0;
/**
* The z-index of the helpers must be higher than the canvases in order for
* IMEs to appear on top.
*/
z-index: 5;
}
.xterm .xterm-helper-textarea {
padding: 0;
border: 0;
margin: 0;
/* Move textarea out of the screen to the far left, so that the cursor is not visible */
position: absolute;
opacity: 0;
left: -9999em;
top: 0;
width: 0;
height: 0;
z-index: -5;
/** Prevent wrapping so the IME appears against the textarea at the correct position */
white-space: nowrap;
overflow: hidden;
resize: none;
}
.xterm .composition-view {
/* TODO: Composition position got messed up somewhere */
background: #000;
color: #FFF;
display: none;
position: absolute;
white-space: nowrap;
z-index: 1;
}
.xterm .composition-view.active {
display: block;
}
.xterm .xterm-viewport {
/* On OS X this is required in order for the scroll bar to appear fully opaque */
background-color: #000;
overflow-y: scroll;
cursor: default;
position: absolute;
right: 0;
left: 0;
top: 0;
bottom: 0;
}
.xterm .xterm-screen {
position: relative;
}
.xterm .xterm-screen canvas {
position: absolute;
left: 0;
top: 0;
}
.xterm .xterm-scroll-area {
visibility: hidden;
}
.xterm-char-measure-element {
display: inline-block;
visibility: hidden;
position: absolute;
top: 0;
left: -9999em;
line-height: normal;
}
.xterm.enable-mouse-events {
/* When mouse events are enabled (eg. tmux), revert to the standard pointer cursor */
cursor: default;
}
.xterm.xterm-cursor-pointer,
.xterm .xterm-cursor-pointer {
cursor: pointer;
}
.xterm.column-select.focus {
/* Column selection mode */
cursor: crosshair;
}
.xterm .xterm-accessibility:not(.debug),
.xterm .xterm-message {
position: absolute;
left: 0;
top: 0;
bottom: 0;
right: 0;
z-index: 10;
color: transparent;
pointer-events: none;
}
.xterm .xterm-accessibility-tree:not(.debug) *::selection {
color: transparent;
}
.xterm .xterm-accessibility-tree {
user-select: text;
white-space: pre;
}
.xterm .live-region {
position: absolute;
left: -9999px;
width: 1px;
height: 1px;
overflow: hidden;
}
.xterm-dim {
/* Dim should not apply to background, so the opacity of the foreground color is applied
* explicitly in the generated class and reset to 1 here */
opacity: 1 !important;
}
.xterm-underline-1 { text-decoration: underline; }
.xterm-underline-2 { text-decoration: double underline; }
.xterm-underline-3 { text-decoration: wavy underline; }
.xterm-underline-4 { text-decoration: dotted underline; }
.xterm-underline-5 { text-decoration: dashed underline; }
.xterm-overline {
text-decoration: overline;
}
.xterm-overline.xterm-underline-1 { text-decoration: overline underline; }
.xterm-overline.xterm-underline-2 { text-decoration: overline double underline; }
.xterm-overline.xterm-underline-3 { text-decoration: overline wavy underline; }
.xterm-overline.xterm-underline-4 { text-decoration: overline dotted underline; }
.xterm-overline.xterm-underline-5 { text-decoration: overline dashed underline; }
.xterm-strikethrough {
text-decoration: line-through;
}
.xterm-screen .xterm-decoration-container .xterm-decoration {
z-index: 6;
position: absolute;
}
.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer {
z-index: 7;
}
.xterm-decoration-overview-ruler {
z-index: 8;
position: absolute;
top: 0;
right: 0;
pointer-events: none;
}
.xterm-decoration-top {
z-index: 2;
position: relative;
}

8
web/chess-client-wasm/lib/xterm.min.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

17
web/chess-client-wasm/terminal.css Normal file
View File

@ -0,0 +1,17 @@
:root {
--host-bg: #11111b;
--host-surface: #1a1b26;
}
body {
margin: 0;
padding: 0;
background: var(--host-bg);
overflow: hidden;
font-family: monospace;
}
#terminal {
width: 100vw;
height: 100vh;
}

110
web/chess-client-wasm/terminal.js Normal file
View File

@ -0,0 +1,110 @@
// FILE: terminal.js
const term = new Terminal({
cursorBlink: true,
convertEol: true,
fontFamily: 'Menlo, Monaco, "Courier New", monospace',
fontSize: 14,
theme: {
background: '#1a1b26',
foreground: '#a9b1d6',
cursor: '#a9b1d6',
selection: 'rgba(169, 177, 214, 0.3)'
},
cols: 120,
rows: 40
});
term.open(document.getElementById('terminal'));
term.focus();
let inputBuffer = '';
let inputResolver = null;
term.onData(data => {
if (inputResolver) {
if (data === '\r') {
term.write('\r\n');
const result = inputBuffer;
inputBuffer = '';
const resolver = inputResolver;
inputResolver = null;
resolver(result);
} else if (data === '\x7f' || data === '\x08') {
if (inputBuffer.length > 0) {
inputBuffer = inputBuffer.slice(0, -1);
term.write('\b \b');
}
} else if (data === '\x03') {
term.write('^C\r\n');
inputBuffer = '';
if (inputResolver) {
inputResolver('');
inputResolver = null;
}
} else if (data >= ' ' && data <= '~') {
inputBuffer += data;
term.write(data);
}
}
});
const encoder = new TextEncoder();
const decoder = new TextDecoder();
// FIXED: Override GLOBAL fs, not go.fs
if (!globalThis.fs) {
globalThis.fs = {};
}
// Store original methods if they exist
const originalWrite = globalThis.fs.write;
const originalRead = globalThis.fs.read;
globalThis.fs.write = function(fd, buf, offset, length, position, callback) {
if (fd === 1 || fd === 2) { // stdout/stderr
const text = decoder.decode(buf.slice(offset, offset + length));
term.write(text);
callback(null, length);
} else if (originalWrite) {
originalWrite.call(this, fd, buf, offset, length, position, callback);
} else {
callback(new Error('Invalid fd'));
}
};
globalThis.fs.read = function(fd, buf, offset, length, position, callback) {
if (fd === 0) { // stdin
const promise = new Promise(resolve => {
inputResolver = resolve;
});
promise.then(line => {
const input = encoder.encode(line + '\n');
const n = Math.min(length, input.length);
buf.set(input.slice(0, n), offset);
callback(null, n);
});
} else if (originalRead) {
originalRead.call(this, fd, buf, offset, length, position, callback);
} else {
callback(new Error('Invalid fd'));
}
};
// Create Go runtime AFTER fs override
const go = new Go();
WebAssembly.instantiateStreaming(fetch('chess-client.wasm'), go.importObject)
.then(result => {
go.run(result.instance);
})
.catch(err => {
term.writeln('\r\n\x1b[31mError loading WASM: ' + err + '\x1b[0m');
console.error('WASM load error:', err);
});
window.addEventListener('resize', () => {
const cols = Math.floor(window.innerWidth / 8);
const rows = Math.floor(window.innerHeight / 17);
term.resize(cols, rows);
});

575
web/chess-client-wasm/wasm_exec.js Normal file
View File

@ -0,0 +1,575 @@
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
"use strict";
(() => {
const enosys = () => {
const err = new Error("not implemented");
err.code = "ENOSYS";
return err;
};
if (!globalThis.fs) {
let outputBuf = "";
globalThis.fs = {
constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1, O_DIRECTORY: -1 }, // unused
writeSync(fd, buf) {
outputBuf += decoder.decode(buf);
const nl = outputBuf.lastIndexOf("\n");
if (nl != -1) {
console.log(outputBuf.substring(0, nl));
outputBuf = outputBuf.substring(nl + 1);
}
return buf.length;
},
write(fd, buf, offset, length, position, callback) {
if (offset !== 0 || length !== buf.length || position !== null) {
callback(enosys());
return;
}
const n = this.writeSync(fd, buf);
callback(null, n);
},
chmod(path, mode, callback) { callback(enosys()); },
chown(path, uid, gid, callback) { callback(enosys()); },
close(fd, callback) { callback(enosys()); },
fchmod(fd, mode, callback) { callback(enosys()); },
fchown(fd, uid, gid, callback) { callback(enosys()); },
fstat(fd, callback) { callback(enosys()); },
fsync(fd, callback) { callback(null); },
ftruncate(fd, length, callback) { callback(enosys()); },
lchown(path, uid, gid, callback) { callback(enosys()); },
link(path, link, callback) { callback(enosys()); },
lstat(path, callback) { callback(enosys()); },
mkdir(path, perm, callback) { callback(enosys()); },
open(path, flags, mode, callback) { callback(enosys()); },
read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
readdir(path, callback) { callback(enosys()); },
readlink(path, callback) { callback(enosys()); },
rename(from, to, callback) { callback(enosys()); },
rmdir(path, callback) { callback(enosys()); },
stat(path, callback) { callback(enosys()); },
symlink(path, link, callback) { callback(enosys()); },
truncate(path, length, callback) { callback(enosys()); },
unlink(path, callback) { callback(enosys()); },
utimes(path, atime, mtime, callback) { callback(enosys()); },
};
}
if (!globalThis.process) {
globalThis.process = {
getuid() { return -1; },
getgid() { return -1; },
geteuid() { return -1; },
getegid() { return -1; },
getgroups() { throw enosys(); },
pid: -1,
ppid: -1,
umask() { throw enosys(); },
cwd() { throw enosys(); },
chdir() { throw enosys(); },
}
}
if (!globalThis.path) {
globalThis.path = {
resolve(...pathSegments) {
return pathSegments.join("/");
}
}
}
if (!globalThis.crypto) {
throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
}
if (!globalThis.performance) {
throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
}
if (!globalThis.TextEncoder) {
throw new Error("globalThis.TextEncoder is not available, polyfill required");
}
if (!globalThis.TextDecoder) {
throw new Error("globalThis.TextDecoder is not available, polyfill required");
}
const encoder = new TextEncoder("utf-8");
const decoder = new TextDecoder("utf-8");
globalThis.Go = class {
constructor() {
this.argv = ["js"];
this.env = {};
this.exit = (code) => {
if (code !== 0) {
console.warn("exit code:", code);
}
};
this._exitPromise = new Promise((resolve) => {
this._resolveExitPromise = resolve;
});
this._pendingEvent = null;
this._scheduledTimeouts = new Map();
this._nextCallbackTimeoutID = 1;
const setInt64 = (addr, v) => {
this.mem.setUint32(addr + 0, v, true);
this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
}
const setInt32 = (addr, v) => {
this.mem.setUint32(addr + 0, v, true);
}
const getInt64 = (addr) => {
const low = this.mem.getUint32(addr + 0, true);
const high = this.mem.getInt32(addr + 4, true);
return low + high * 4294967296;
}
const loadValue = (addr) => {
const f = this.mem.getFloat64(addr, true);
if (f === 0) {
return undefined;
}
if (!isNaN(f)) {
return f;
}
const id = this.mem.getUint32(addr, true);
return this._values[id];
}
const storeValue = (addr, v) => {
const nanHead = 0x7FF80000;
if (typeof v === "number" && v !== 0) {
if (isNaN(v)) {
this.mem.setUint32(addr + 4, nanHead, true);
this.mem.setUint32(addr, 0, true);
return;
}
this.mem.setFloat64(addr, v, true);
return;
}
if (v === undefined) {
this.mem.setFloat64(addr, 0, true);
return;
}
let id = this._ids.get(v);
if (id === undefined) {
id = this._idPool.pop();
if (id === undefined) {
id = this._values.length;
}
this._values[id] = v;
this._goRefCounts[id] = 0;
this._ids.set(v, id);
}
this._goRefCounts[id]++;
let typeFlag = 0;
switch (typeof v) {
case "object":
if (v !== null) {
typeFlag = 1;
}
break;
case "string":
typeFlag = 2;
break;
case "symbol":
typeFlag = 3;
break;
case "function":
typeFlag = 4;
break;
}
this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
this.mem.setUint32(addr, id, true);
}
const loadSlice = (addr) => {
const array = getInt64(addr + 0);
const len = getInt64(addr + 8);
return new Uint8Array(this._inst.exports.mem.buffer, array, len);
}
const loadSliceOfValues = (addr) => {
const array = getInt64(addr + 0);
const len = getInt64(addr + 8);
const a = new Array(len);
for (let i = 0; i < len; i++) {
a[i] = loadValue(array + i * 8);
}
return a;
}
const loadString = (addr) => {
const saddr = getInt64(addr + 0);
const len = getInt64(addr + 8);
return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
}
const testCallExport = (a, b) => {
this._inst.exports.testExport0();
return this._inst.exports.testExport(a, b);
}
const timeOrigin = Date.now() - performance.now();
this.importObject = {
_gotest: {
add: (a, b) => a + b,
callExport: testCallExport,
},
gojs: {
// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
// This changes the SP, thus we have to update the SP used by the imported function.
// func wasmExit(code int32)
"runtime.wasmExit": (sp) => {
sp >>>= 0;
const code = this.mem.getInt32(sp + 8, true);
this.exited = true;
delete this._inst;
delete this._values;
delete this._goRefCounts;
delete this._ids;
delete this._idPool;
this.exit(code);
},
// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
"runtime.wasmWrite": (sp) => {
sp >>>= 0;
const fd = getInt64(sp + 8);
const p = getInt64(sp + 16);
const n = this.mem.getInt32(sp + 24, true);
fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
},
// func resetMemoryDataView()
"runtime.resetMemoryDataView": (sp) => {
sp >>>= 0;
this.mem = new DataView(this._inst.exports.mem.buffer);
},
// func nanotime1() int64
"runtime.nanotime1": (sp) => {
sp >>>= 0;
setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
},
// func walltime() (sec int64, nsec int32)
"runtime.walltime": (sp) => {
sp >>>= 0;
const msec = (new Date).getTime();
setInt64(sp + 8, msec / 1000);
this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
},
// func scheduleTimeoutEvent(delay int64) int32
"runtime.scheduleTimeoutEvent": (sp) => {
sp >>>= 0;
const id = this._nextCallbackTimeoutID;
this._nextCallbackTimeoutID++;
this._scheduledTimeouts.set(id, setTimeout(
() => {
this._resume();
while (this._scheduledTimeouts.has(id)) {
// for some reason Go failed to register the timeout event, log and try again
// (temporary workaround for https://github.com/golang/go/issues/28975)
console.warn("scheduleTimeoutEvent: missed timeout event");
this._resume();
}
},
getInt64(sp + 8),
));
this.mem.setInt32(sp + 16, id, true);
},
// func clearTimeoutEvent(id int32)
"runtime.clearTimeoutEvent": (sp) => {
sp >>>= 0;
const id = this.mem.getInt32(sp + 8, true);
clearTimeout(this._scheduledTimeouts.get(id));
this._scheduledTimeouts.delete(id);
},
// func getRandomData(r []byte)
"runtime.getRandomData": (sp) => {
sp >>>= 0;
crypto.getRandomValues(loadSlice(sp + 8));
},
// func finalizeRef(v ref)
"syscall/js.finalizeRef": (sp) => {
sp >>>= 0;
const id = this.mem.getUint32(sp + 8, true);
this._goRefCounts[id]--;
if (this._goRefCounts[id] === 0) {
const v = this._values[id];
this._values[id] = null;
this._ids.delete(v);
this._idPool.push(id);
}
},
// func stringVal(value string) ref
"syscall/js.stringVal": (sp) => {
sp >>>= 0;
storeValue(sp + 24, loadString(sp + 8));
},
// func valueGet(v ref, p string) ref
"syscall/js.valueGet": (sp) => {
sp >>>= 0;
const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 32, result);
},
// func valueSet(v ref, p string, x ref)
"syscall/js.valueSet": (sp) => {
sp >>>= 0;
Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
},
// func valueDelete(v ref, p string)
"syscall/js.valueDelete": (sp) => {
sp >>>= 0;
Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
},
// func valueIndex(v ref, i int) ref
"syscall/js.valueIndex": (sp) => {
sp >>>= 0;
storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
},
// valueSetIndex(v ref, i int, x ref)
"syscall/js.valueSetIndex": (sp) => {
sp >>>= 0;
Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
},
// func valueCall(v ref, m string, args []ref) (ref, bool)
"syscall/js.valueCall": (sp) => {
sp >>>= 0;
try {
const v = loadValue(sp + 8);
const m = Reflect.get(v, loadString(sp + 16));
const args = loadSliceOfValues(sp + 32);
const result = Reflect.apply(m, v, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 56, result);
this.mem.setUint8(sp + 64, 1);
} catch (err) {
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 56, err);
this.mem.setUint8(sp + 64, 0);
}
},
// func valueInvoke(v ref, args []ref) (ref, bool)
"syscall/js.valueInvoke": (sp) => {
sp >>>= 0;
try {
const v = loadValue(sp + 8);
const args = loadSliceOfValues(sp + 16);
const result = Reflect.apply(v, undefined, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, result);
this.mem.setUint8(sp + 48, 1);
} catch (err) {
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, err);
this.mem.setUint8(sp + 48, 0);
}
},
// func valueNew(v ref, args []ref) (ref, bool)
"syscall/js.valueNew": (sp) => {
sp >>>= 0;
try {
const v = loadValue(sp + 8);
const args = loadSliceOfValues(sp + 16);
const result = Reflect.construct(v, args);
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, result);
this.mem.setUint8(sp + 48, 1);
} catch (err) {
sp = this._inst.exports.getsp() >>> 0; // see comment above
storeValue(sp + 40, err);
this.mem.setUint8(sp + 48, 0);
}
},
// func valueLength(v ref) int
"syscall/js.valueLength": (sp) => {
sp >>>= 0;
setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
},
// valuePrepareString(v ref) (ref, int)
"syscall/js.valuePrepareString": (sp) => {
sp >>>= 0;
const str = encoder.encode(String(loadValue(sp + 8)));
storeValue(sp + 16, str);
setInt64(sp + 24, str.length);
},
// valueLoadString(v ref, b []byte)
"syscall/js.valueLoadString": (sp) => {
sp >>>= 0;
const str = loadValue(sp + 8);
loadSlice(sp + 16).set(str);
},
// func valueInstanceOf(v ref, t ref) bool
"syscall/js.valueInstanceOf": (sp) => {
sp >>>= 0;
this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
},
// func copyBytesToGo(dst []byte, src ref) (int, bool)
"syscall/js.copyBytesToGo": (sp) => {
sp >>>= 0;
const dst = loadSlice(sp + 8);
const src = loadValue(sp + 32);
if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
this.mem.setUint8(sp + 48, 0);
return;
}
const toCopy = src.subarray(0, dst.length);
dst.set(toCopy);
setInt64(sp + 40, toCopy.length);
this.mem.setUint8(sp + 48, 1);
},
// func copyBytesToJS(dst ref, src []byte) (int, bool)
"syscall/js.copyBytesToJS": (sp) => {
sp >>>= 0;
const dst = loadValue(sp + 8);
const src = loadSlice(sp + 16);
if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
this.mem.setUint8(sp + 48, 0);
return;
}
const toCopy = src.subarray(0, dst.length);
dst.set(toCopy);
setInt64(sp + 40, toCopy.length);
this.mem.setUint8(sp + 48, 1);
},
"debug": (value) => {
console.log(value);
},
}
};
}
async run(instance) {
if (!(instance instanceof WebAssembly.Instance)) {
throw new Error("Go.run: WebAssembly.Instance expected");
}
this._inst = instance;
this.mem = new DataView(this._inst.exports.mem.buffer);
this._values = [ // JS values that Go currently has references to, indexed by reference id
NaN,
0,
null,
true,
false,
globalThis,
this,
];
this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
this._ids = new Map([ // mapping from JS values to reference ids
[0, 1],
[null, 2],
[true, 3],
[false, 4],
[globalThis, 5],
[this, 6],
]);
this._idPool = []; // unused ids that have been garbage collected
this.exited = false; // whether the Go program has exited
// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
let offset = 4096;
const strPtr = (str) => {
const ptr = offset;
const bytes = encoder.encode(str + "\0");
new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
offset += bytes.length;
if (offset % 8 !== 0) {
offset += 8 - (offset % 8);
}
return ptr;
};
const argc = this.argv.length;
const argvPtrs = [];
this.argv.forEach((arg) => {
argvPtrs.push(strPtr(arg));
});
argvPtrs.push(0);
const keys = Object.keys(this.env).sort();
keys.forEach((key) => {
argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
});
argvPtrs.push(0);
const argv = offset;
argvPtrs.forEach((ptr) => {
this.mem.setUint32(offset, ptr, true);
this.mem.setUint32(offset + 4, 0, true);
offset += 8;
});
// The linker guarantees global data starts from at least wasmMinDataAddr.
// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
const wasmMinDataAddr = 4096 + 8192;
if (offset >= wasmMinDataAddr) {
throw new Error("total length of command line and environment variables exceeds limit");
}
this._inst.exports.run(argc, argv);
if (this.exited) {
this._resolveExitPromise();
}
await this._exitPromise;
}
_resume() {
if (this.exited) {
throw new Error("Go program has already exited");
}
this._inst.exports.resume();
if (this.exited) {
this._resolveExitPromise();
}
}
_makeFuncWrapper(id) {
const go = this;
return function () {
const event = { id: id, this: this, args: arguments };
go._pendingEvent = event;
go._resume();
return event.result;
};
}
}
})();

1
web/chess-client-web Symbolic link
View File

@ -0,0 +1 @@
../internal/server/webserver/chess-client-web