js-dos 7.5.0 → 8.1.1

package/src/ws/ws-transport-layer.ts

@@ -0,0 +1,468 @@
+import {
+    TransportLayer, ClientMessage, MessageHandler,
+    ServerMessage, DataChunk, FsNode,
+} from "emulators/dist/types/protocol/protocol";
+
+import { createSockdrive } from "./ws-sockdrive";
+
+const sockdriveConfirmWrite = false;
+
+export interface Hardware {
+    readConfig(): string;
+    sendMessage(payload: string): void;
+    addKey(key: number, pressed: number, timeMs: number): void;
+    mouseMove(x: number, y: number, relative: boolean, timeMs: number): void;
+    mouseButton(button: number, pressed: number, timeMs: number): void;
+    getFramePayload(): string;
+
+    createFile(path: string): string;
+    appendFile(blob: string): string;
+    writeFile(path: string): string;
+    closeFile(): string;
+}
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+const fMultiplier = 200000000;
+
+// eslint-disable-next-line max-len
+const clientMessageValues: ClientMessage[] = [
+    "wc-install", "wc-run", "wc-pack-fs-to-bundle", "wc-add-key", "wc-mouse-move", "wc-mouse-button", "wc-mouse-sync",
+    "wc-exit", "wc-sync-sleep", "wc-pause", "wc-resume", "wc-mute", "wc-unmute", "wc-connect", "wc-disconnect",
+    "wc-backend-event", "wc-asyncify-stats", "wc-fs-tree", "wc-fs-get-file", "wc-send-data-chunk",
+];
+const clientMessageEnum: { [msg: string]: number } = {};
+clientMessageValues.forEach((v, i) => clientMessageEnum[v] = i);
+
+const serverMessageValues: ServerMessage[] = [
+    "ws-extract-progress", "ws-ready", "ws-server-ready", "ws-frame-set-size",
+    "ws-update-lines", "ws-log", "ws-warn", "ws-err",
+    "ws-stdout", "ws-exit", "ws-persist", "ws-sound-init", "ws-sound-push",
+    "ws-config", "ws-sync-sleep", "ws-connected", "ws-disconnected",
+    "ws-asyncify-stats", "ws-fs-tree", "ws-send-data-chunk",
+];
+const serverMessageEnum: { [num: string]: ServerMessage } = {};
+serverMessageValues.forEach((v, i) => serverMessageEnum[i] = v);
+
+export class WsTransportLayer implements TransportLayer {
+    socket: WebSocket;
+    sessionId: string = Date.now() + "";
+    hardware: Hardware;
+    onInit: (version: number) => void = {/**/};
+
+    private cycles = 0;
+    private sockdrive = createSockdrive(this.onSockdriveOpen.bind(this),
+        this.onSockdriveError.bind(this), this.onSockdrivePreloadProgress.bind(this));
+
+    private handler: MessageHandler = () => {/**/};
+
+    private writeUint32(container: Uint8Array, value: number, offset: number) {
+        container[offset] = value & 0xFF;
+        container[offset + 1] = (value & 0x0000FF00) >> 8;
+        container[offset + 2] = (value & 0x00FF0000) >> 16;
+        container[offset + 3] = (value & 0xFF000000) >> 24;
+        return offset + 4;
+    }
+
+    private readUint32(container: Uint8Array, offset: number) {
+        return (container[offset] & 0x000000FF) |
+            ((container[offset + 1] << 8) & 0x0000FF00) |
+            ((container[offset + 2] << 16) & 0x00FF0000) |
+            ((container[offset + 3] << 24) & 0xFF000000);
+    }
+
+    private readUint64(container: Uint8Array, offset: number) {
+        return this.readUint32(container, offset) + this.readUint32(container, offset + 4) * 2 ** 32;
+    }
+
+    private sendMessageToSocket(id: ClientMessage | number, ...payload: (Uint8Array | null)[]) {
+        let length = 1;
+        for (const next of payload) {
+            length += 4 + (next?.length ?? 0);
+        }
+
+        const encoded = new Uint8Array(length);
+        encoded[0] = typeof id === "string" ? clientMessageEnum[id] : id;
+        let position = 1;
+        for (const next of payload) {
+            this.writeUint32(encoded, next?.length ?? 0, position);
+            position += 4;
+            if (next) {
+                encoded.set(next, position);
+                position += next.length;
+            }
+        }
+
+        this.socket.send(encoded);
+    }
+
+    private readMessage(payload: Uint8Array): { id: number, payload: (Uint8Array | null)[] } {
+        const out: Uint8Array[] = [];
+        let position = 1;
+        while (position + 4 <= payload.length) {
+            const length = this.readUint32(payload, position);
+            position += 4;
+
+            if (position + length > payload.length) {
+                throw new Error("read_message out of bounds");
+            } else {
+                out.push(payload.slice(position, position + length));
+            }
+
+            position += length;
+        }
+
+        return {
+            id: payload[0],
+            payload: out,
+        };
+    }
+
+    private onMessage(msg: Uint8Array) {
+        const { id, payload } = this.readMessage(msg);
+        const message = serverMessageEnum[id];
+        switch (message) {
+            case "ws-ready": {
+                this.onInit((payload && payload[0] && payload.length > 0) ? payload[0][0] : 0);
+                this.handler(message, {});
+            } break;
+            case "ws-server-ready":
+            case "ws-exit": {
+                // delay ws-server-ready until ws-sound-init
+                if (message !== "ws-server-ready") {
+                    this.handler(message, {});
+                }
+            } break;
+            case "ws-stdout":
+            case "ws-log":
+            case "ws-warn":
+            case "ws-err": {
+                this.handler(message, {
+                    tag: textDecoder.decode(payload[0]!),
+                    message: textDecoder.decode(payload[1]!),
+                });
+            } break;
+            case "ws-send-data-chunk": {
+                const chunk: DataChunk = {
+                    type: textDecoder.decode(payload[0]!) as any,
+                    name: textDecoder.decode(payload[1]!),
+                    data: payload[2],
+                };
+                this.handler(message, { chunk });
+            } break;
+            case "ws-config": {
+                this.handler(message, {
+                    dosboxConf: payload[0]!,
+                    jsdosConf: textDecoder.decode(payload[1]!),
+                });
+            } break;
+            case "ws-sound-init": {
+                this.handler(message, {
+                    freq: this.readUint32(payload[0]!, 0),
+                });
+                this.handler("ws-server-ready", {});
+            } break;
+            case "ws-sound-push": {
+                this.handler(message, {
+                    samples: new Float32Array(payload[0]!.buffer),
+                });
+            } break;
+            case "ws-frame-set-size": {
+                this.handler(message, {
+                    width: this.readUint32(payload[0]!, 0),
+                    height: this.readUint32(payload[0]!, 4),
+                });
+            } break;
+            case "ws-update-lines": {
+                if (payload.length > 0) {
+                    const lines: { start: number, heapu8: Uint8Array }[] = [];
+                    for (const next of payload) {
+                        lines.push({
+                            start: this.readUint32(next!, 0),
+                            heapu8: next!.slice(4),
+                        });
+                    }
+                    this.handler(message, { lines });
+                }
+            } break;
+            case "ws-asyncify-stats": {
+                this.cycles += this.readUint32(payload[0]!, 0);
+                const stats = {
+                    messageSent: this.readUint32(payload[0]!, 4),
+                    messageReceived: this.readUint32(payload[0]!, 8),
+                    messageFrame: this.readUint32(payload[0]!, 12),
+                    messageSound: this.readUint32(payload[0]!, 16),
+                    nonSkippableSleepCount: 0,
+                    sleepCount: 0,
+                    sleepTime: 0,
+                    cycles: this.cycles,
+                    netSent: 0,
+                    netRecv: 0,
+                    driveSent: this.sockdrive.stats.write,
+                    driveRecv: this.sockdrive.stats.read,
+                    driveRecvTime: this.sockdrive.stats.readTotalTime,
+                    driveCacheHit: this.sockdrive.stats.cacheHit,
+                    driveCacheMiss: this.sockdrive.stats.cacheMiss,
+                    driveCacheUsed: this.sockdrive.stats.cacheUsed,
+                };
+                this.handler(message, stats);
+            } break;
+            case "ws-connected": {
+                this.handler(message, { networkType: payload[0]![0], address: textDecoder.decode(payload[1]!) });
+            } break;
+            case "ws-disconnected": {
+                this.handler(message, { networkType: payload[0]![0] });
+            } break;
+            case "ws-fs-tree": {
+                const info: { name: string, size: number | null }[] = [];
+                for (let i = 0; i < payload.length - 1; ++i) {
+                    info.push({ name: textDecoder.decode(payload[i]!), size: null });
+                }
+
+                const sizes = payload[payload.length - 1]!;
+                for (let i = 0; i < info.length; ++i) {
+                    const size = this.readUint32(sizes, i * 4);
+                    info[i].size = size < 0 ? null : size;
+                }
+
+                const fsTree: FsNode = {
+                    name: ".",
+                    nodes: [],
+                    size: null,
+                };
+
+                function lookupNode(name: string): [FsNode, string] {
+                    const parts = name.split("/");
+                    let node: FsNode | undefined = fsTree;
+                    for (let i = 1; i < parts.length - 1; ++i) {
+                        const dir = parts[i];
+                        node = node!.nodes?.find((n) => n.name == dir);
+                        if (!node) {
+                            throw new Error("Unable to find node " + name + ", subdir " + dir);
+                        }
+                    }
+                    return [node, parts[parts.length - 1]];
+                };
+
+                for (const { name, size } of info) {
+                    const [node, basename] = lookupNode(name);
+                    node.nodes?.push({
+                        name: basename,
+                        size,
+                        nodes: size === null ? [] : null,
+                    });
+                }
+
+                this.handler("ws-fs-tree", {
+                    fsTree,
+                });
+            } break;
+            case "ws-persist": {
+                this.handler("ws-persist", {
+                    bundle: payload.length > 0 ? payload[0]! : null,
+                });
+            } break;
+            default: {
+                if (message === undefined) { // not standard messages
+                    (async () => {
+                        switch (id) {
+                            case 100/* ws-sockdrive-open */: {
+                                const url = textDecoder.decode(payload[0]!);
+                                const owner = textDecoder.decode(payload[1]!);
+                                const name = textDecoder.decode(payload[2]!);
+                                const token = textDecoder.decode(payload[3]!);
+                                const { handle, aheadRange } = await this.sockdrive.open(url, owner, name, token);
+                                const template = this.sockdrive.template(handle);
+                                const packet = new Uint8Array(4 * 7);
+                                let offset = 0;
+                                offset = this.writeUint32(packet, handle, offset);
+                                offset = this.writeUint32(packet, template.size, offset);
+                                offset = this.writeUint32(packet, template.heads, offset);
+                                offset = this.writeUint32(packet, template.cylinders, offset);
+                                offset = this.writeUint32(packet, template.sectors, offset);
+                                offset = this.writeUint32(packet, template.sectorSize, offset);
+                                this.writeUint32(packet, aheadRange, offset);
+                                this.sendMessageToSocket(100, packet);
+                            } break;
+                            case 101/* ws-sockdrive-read */: {
+                                const handle = this.readUint32(payload[0]!, 0);
+                                const sector = this.readUint32(payload[0]!, 4);
+                                const response = await this.sockdrive.read(handle, sector);
+                                const packet = new Uint8Array(4);
+                                this.writeUint32(packet, response.code, 0);
+                                this.sendMessageToSocket(101, packet, response.buffer ?? null);
+                            } break;
+                            case 102/* ws-sockdrive-write */: {
+                                const handle = this.readUint32(payload[0]!, 0);
+                                const sector = this.readUint32(payload[0]!, 4);
+                                const code = this.sockdrive.write(handle, sector, payload[1]!);
+                                const packet = new Uint8Array(4);
+                                this.writeUint32(packet, code, 0);
+                                if (sockdriveConfirmWrite) {
+                                    this.sendMessageToSocket(102, packet);
+                                }
+                            } break;
+                            case 103/* ws-sockdrive-close */: {
+                                this.sockdrive.close(this.readUint32(payload[0]!, 0));
+                            } break;
+                            default:
+                                console.log("WARN! Unhandled server non standard message", id, payload);
+                        }
+                    })().catch((e) => {
+                        this.handler("ws-err", {
+                            tag: "panic",
+                            message: "sockdrive error: " + (e.message ?? "???"),
+                        });
+                    });
+                } else {
+                    console.warn("WARN! Unhandled server message", message);
+                }
+            }
+        }
+    }
+
+    constructor(socket: WebSocket, onInit: (version: number) => void) {
+        this.socket = socket;
+        this.socket.addEventListener("error", (e) => {
+            this.handler("ws-err", { tag: "ws", message: (e as any).message ?? "Unknown transport layer error" });
+            this.handler("ws-exit", {});
+            this.socket.close();
+        });
+        this.socket.addEventListener("message", async (ev) => {
+            const blob: Blob = ev.data;
+            this.onMessage(new Uint8Array(await blob.arrayBuffer()));
+        });
+        this.sendMessageToSocket("wc-install");
+        this.hardware = (null) as any;
+        this.onInit = onInit;
+    }
+
+    async sendMessageToServer(name: ClientMessage, props?: { [key: string]: any; }) {
+        if (props === undefined || props?.sessionId !== this.sessionId) {
+            return;
+        }
+
+        const messageId = clientMessageEnum[name];
+        switch (name) {
+            case "wc-run": {
+                const token = props.token ?? "";
+                this.sendMessageToSocket(messageId, textEncoder.encode(token));
+            } break;
+            case "wc-send-data-chunk": {
+                const chunk: DataChunk = props.chunk;
+                this.sendMessageToSocket(messageId,
+                    textEncoder.encode(chunk.type),
+                    textEncoder.encode(chunk.name),
+                    chunk.data ? new Uint8Array(chunk.data) : null);
+            } break;
+            case "wc-asyncify-stats": {
+                this.sendMessageToSocket(messageId);
+            } break;
+            case "wc-add-key": {
+                const payload = new Uint8Array(3 * 4);
+                let offset = 0;
+                offset = this.writeUint32(payload, props.key, offset);
+                offset = this.writeUint32(payload, props.pressed ? 1 : 0, offset);
+                this.writeUint32(payload, props.timeMs, offset);
+                this.sendMessageToSocket(messageId, payload);
+            } break;
+            case "wc-mouse-move": {
+                const payload = new Uint8Array(3 * 4 + 3);
+                let offset = 0;
+                offset = this.writeUint32(payload, Math.abs(props.x) * fMultiplier, offset);
+                offset = this.writeUint32(payload, Math.abs(props.y) * fMultiplier, offset);
+                offset = this.writeUint32(payload, props.timeMs, offset);
+                payload[offset] = props.relative ? 1 : 0;
+                payload[offset + 1] = props.x >= 0 ? 0 : 1;
+                payload[offset + 2] = props.y >= 0 ? 0 : 1;
+                this.sendMessageToSocket(messageId, payload);
+            } break;
+            case "wc-mouse-button": {
+                const payload = new Uint8Array(4 + 2);
+                payload[0] = props.button;
+                payload[1] = props.pressed ? 1 : 0;
+                this.writeUint32(payload, props.timeMs, 2);
+                this.sendMessageToSocket(messageId, payload);
+            } break;
+            case "wc-mouse-sync": {
+                const payload = new Uint8Array(4);
+                this.writeUint32(payload, props.timeMs, 0);
+                this.sendMessageToSocket(messageId, payload);
+            } break;
+            case "wc-connect": {
+                this.sendMessageToSocket(messageId, new Uint8Array([props.networkType]),
+                    textEncoder.encode(props.address));
+            } break;
+            case "wc-fs-tree": {
+                this.sendMessageToSocket(messageId);
+            } break;
+            case "wc-pack-fs-to-bundle": {
+                this.sendMessageToSocket(messageId, new Uint8Array([props.onlyChanges ? 1 : 0]));
+            } break;
+            default: {
+                console.log("Unhandled client message (wc):", name, messageId, props);
+            } break;
+        }
+    }
+
+    initMessageHandler(handler: MessageHandler) {
+        this.handler = (message, props) => {
+            props.sessionId = this.sessionId;
+            handler(message, props);
+        };
+    }
+
+    exit() {
+        this.sendMessageToSocket("wc-exit");
+    }
+
+    onSockdriveOpen(drive: string, read: boolean, write: boolean, imageSize: number, preloadQueue: number[]) {
+        this.handler("ws-log", {
+            tag: "worker",
+            message: "sockdrive: " + drive + ", read=" + read + ", write=" + write +
+                ", imageSize=" + Math.round(imageSize / 1024 / 1024) + "Mb" + ", preloadQueue=" + preloadQueue.length,
+        });
+    }
+
+    onSockdriveError(e: Error) {
+        this.handler("ws-err", {
+            tag: "panic",
+            message: e.message ?? "unable to open sockdrive",
+        });
+    }
+
+    onSockdrivePreloadProgress(drive: string, restBytes: number) {
+        this.handler("ws-log", {
+            tag: "worker",
+            message: "sockdrive: " + drive + ", preload=" + restBytes,
+        });
+    }
+}
+
+export function createWsTransportLayer(url: string, onInit: (version: number) => void): Promise<TransportLayer> {
+    return new Promise<TransportLayer>((resolve) => {
+        let locked = false;
+        const inervalId = setInterval(() => {
+            if (locked) {
+                return;
+            }
+
+            locked = true;
+            const ws = new WebSocket(url);
+            const onSuccess = () => {
+                clearInterval(inervalId);
+                console.log("Connected to", url);
+                resolve(new WsTransportLayer(ws, onInit));
+            };
+
+            ws.addEventListener("error", (error) => {
+                console.error("Can't conect to ", url, error);
+                ws.removeEventListener("open", onSuccess);
+                ws.close();
+                locked = false;
+            });
+
+            ws.addEventListener("open", onSuccess);
+        }, 1000);
+    });
+}

package/tailwind.config.cjs

@@ -0,0 +1,48 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+    content: [
+        "./index.html",
+        "./src/**/*.{js,ts,jsx,tsx}",
+    ],
+    theme: {
+        extend: {},
+    },
+    plugins: [require("daisyui")],
+    safelist: [
+        "alert-success",
+        "alert-error",
+    ],
+    daisyui: {
+        themes: [
+            "light",
+            "dark",
+            "cupcake",
+            "bumblebee",
+            "emerald",
+            "corporate",
+            "synthwave",
+            "retro",
+            "cyberpunk",
+            "valentine",
+            "halloween",
+            "garden",
+            "forest",
+            "aqua",
+            "lofi",
+            "pastel",
+            "fantasy",
+            "wireframe",
+            "black",
+            "luxury",
+            "dracula",
+            "cmyk",
+            "autumn",
+            "business",
+            "acid",
+            "lemonade",
+            "night",
+            "coffee",
+            "winter",
+        ],
+    }
+};

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "react": ["./node_modules/preact/compat/"],
+      "react-dom": ["./node_modules/preact/compat/"]
+    },
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact"
+  },
+  "include": ["src"],
+  "exclude": [
+    "src/sockdrive/js/src/test", 
+    "src/sockdrive/js/src/sockdrive-fat.ts", 
+    "src/sockdrive/js/src/sockdrive-native.ts", 
+    "src/sockdrive/js/src/fatfs"
+  ],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from "vite";
+import preact from "@preact/preset-vite";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+    plugins: [preact()],
+    server: {
+        port: 3000,
+        host: "0.0.0.0",
+        cors: true,
+    },
+    build: {
+        rollupOptions: {
+            output: {
+                entryFileNames: "js-dos.js",
+                assetFileNames: (info) => {
+                    return info.name === "index.css" ? "js-dos.css" : info.name;
+                },
+            },
+        },
+    },
+});