@bytecodealliance/preview2-shim 0.0.4 → 0.0.5

package/lib/browser/environment-preopens.js

@@ -0,0 +1,3 @@
+export function preopens () {
+  return [];
+}

package/lib/browser/http.js

@@ -9,19 +9,24 @@ export function send(req) {
   try {
     const xhr = new XMLHttpRequest();
     xhr.open(req.method.toString(), req.uri, false);
-    for (let [name, value] of req.headers) {
-      if (name !== "user-agent") {
+    const requestHeaders = new Headers(req.headers);
+    for (let [name, value] of requestHeaders.entries()) {
+      if (name !== "user-agent" && name !== "host") {
         xhr.setRequestHeader(name, value);
       }
     }
-    xhr.send(req.body.length > 0 ? req.body : null);
+    xhr.send(req.body && req.body.length > 0 ? req.body : null);
     const body = xhr.response ? new TextEncoder().encode(xhr.response) : undefined;
+    const headers = [];
+    xhr.getAllResponseHeaders().trim().split(/[\r\n]+/).forEach((line) => {
+      var parts = line.split(': ');
+      var key = parts.shift();
+      var value = parts.join(': ');
+      headers.push([key, value]);
+    });
     return {
       status: xhr.status,
-      headers: xhr
-        .getAllResponseHeaders()
-        .trim()
-        .split(/[\r\n]+/),
+      headers,
       body,
     };
   } catch (err) {

package/lib/browser/index.js

@@ -1,13 +1,16 @@
-import * as defaultClocks from "./default-clocks.js";
+import * as console from "./console.js";
 import * as defaultOutgoingHttp from "./default-outgoing-HTTP.js";
 import * as environment from "./environment.js";
+import * as environmentPreopens from "./environment-preopens.js";
 import * as exit from "./exit.js";
 import * as filesystem from "./filesystem.js";
 import * as http from "./http.js";
+import * as instanceMonotonicClock from "./instance-monotonic-clock.js";
+import * as instanceWallClock from "./instance-wall-clock.js";
 import * as io from "./io.js";
-import * as logging from "./console.js";
 import * as monotonicClock from "./monotonic-clock.js";
 import * as poll from "./poll.js";
+import * as preopens from "./preopens.js";
 import * as random from "./random.js";
 import * as stderr from "./stderr.js";
 import * as streams from "./streams.js";
@@ -15,16 +18,19 @@ import * as types from "./types.js";
 import * as wallClock from "./wall-clock.js";
 
 export const importObject = {
-    "default-clocks": defaultClocks,
+    "console": console,
     "default-outgoing-HTTP": defaultOutgoingHttp,
     "environment": environment,
+    "environment-preopens": environmentPreopens,
     "exit": exit,
     "filesystem": filesystem,
     "http": http,
+    "instance-monotonic-clock": instanceMonotonicClock,
+    "instance-wall-clock": instanceWallClock,
     "io": io,
-    "logging": logging,
     "monotonic-clock": monotonicClock,
     "poll": poll,
+    "preopens": preopens,
     "random": random,
     "stderr": stderr,
     "streams": streams,
@@ -32,4 +38,6 @@ export const importObject = {
     "wall-clock": wallClock,
 };
 
+export { WasiHttp } from "../http/wasi-http.js";
+
 export default importObject;

package/lib/browser/instance-monotonic-clock.js

@@ -0,0 +1,3 @@
+export function instanceMonotonicClock() {
+  return 0;
+}

package/lib/browser/instance-wall-clock.js

@@ -0,0 +1,3 @@
+export function instanceWallClock() {
+  return 1;
+}

package/lib/browser/io.js

@@ -1,17 +1,9 @@
-export function dropInputStream(f) {
-  console.log(`[io] Drop input stream ${f}`);
+export function read(s, len) {
+  console.log(`[io] Read ${s} ${len}`);
 }
 
-export function dropOutputStream(f) {
-  console.log(`[io] Drop output stream ${f}`);
-}
-
-export function read(src, len) {
-  console.log(`[io] Read ${src} ${len}`);
-}
-
-export function write(dst, buf) {
-  switch (dst) {
+export function write(s, buf) {
+  switch (s) {
     case 0:
       throw new Error(`TODO: write stdin`);
     case 1: {
@@ -19,17 +11,12 @@ export function write(dst, buf) {
       console.log(decoder.decode(buf));
       return BigInt(buf.byteLength);
     }
-    case 2:
-      throw new Error(`TODO: write stdout`);
+    case 2: {
+      const decoder = new TextDecoder();
+      console.error(decoder.decode(buf));
+      return BigInt(buf.byteLength);
+    }
     default:
-      throw new Error(`TODO: write ${dst}`);
+      throw new Error(`TODO: write ${s}`);
   }
 }
-
-export function skip(src, len) {
-  console.log(`[io] Skip ${src}`, len);
-}
-
-export function write_repeated(dst, byte, len) {
-  console.log(`[io] Write repeated ${dst}`, byte, len);
-}

package/lib/browser/preopens.js

@@ -0,0 +1,11 @@
+export function getStdio () {
+  return {
+    stdin: 0,
+    stdout: 1,
+    stderr: 2,
+  };
+}
+
+export function getDirectories () {
+  return [];
+}

package/lib/browser/random.js

@@ -1,7 +1,7 @@
 const MAX_BYTES = 65536;
 
 export function getRandomBytes(len) {
-  const bytes = new Uint8Array(len);
+  const bytes = new Uint8Array(Number(len));
 
   if (len > MAX_BYTES) {
     // this is the max bytes crypto.getRandomValues

package/lib/browser/streams.js

@@ -16,8 +16,23 @@ export function subscribeToInputStream(s) {
 export function dropInputStream(s) {
   console.log(`[streams] Drop input stream ${s}`);
 }
-export function write(s, _buf) {
-  console.log(`[streams] Write ${s}`);
+export function write(s, buf) {
+  switch (s) {
+    case 0:
+      throw new Error(`TODO: write stdin`);
+    case 1: {
+      const decoder = new TextDecoder();
+      console.log(decoder.decode(buf));
+      return BigInt(buf.byteLength);
+    }
+    case 2: {
+      const decoder = new TextDecoder();
+      console.error(decoder.decode(buf));
+      return BigInt(buf.byteLength);
+    }
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
 }
 export function blockingWrite(s, _buf) {
   console.log(`[streams] Blocking write ${s}`);

package/lib/http/make-request.js

@@ -10,12 +10,12 @@ async function makeRequest(req) {
     const resp = await fetch(req.uri, {
       method: req.method.toString(),
       headers,
-      body: req.body.length > 0 ? req.body : undefined,
+      body: req.body && req.body.length > 0 ? req.body : undefined,
     });
     let arrayBuffer = await resp.arrayBuffer();
     return JSON.stringify({
       status: resp.status,
-      headers: resp.headers,
+      headers: Array.from(resp.headers.entries()),
       body:
         arrayBuffer.byteLength > 0
           ? Buffer.from(arrayBuffer).toString("base64")

package/lib/http/wasi-http.js

@@ -0,0 +1,267 @@
+// Based on:
+// https://github.com/bytecodealliance/wasmtime/blob/76eb40e0756d90cc9c16b26a8d8b1e0ebf75f44d/crates/wasi-http/src/http_impl.rs
+
+/**
+ * @typedef {import("../../types/imports/types").Fields} Fields
+ * @typedef {import("../../types/imports/types").FutureIncomingResponse} FutureIncomingResponse
+ * @typedef {import("../../types/imports/types").Headers} Headers
+ * @typedef {import("../../types/imports/types").IncomingResponse} IncomingResponse
+ * @typedef {import("../../types/imports/types").IncomingStream} IncomingStream
+ * @typedef {import("../../types/imports/types").Method} Method
+ * @typedef {import("../../types/imports/types").OutgoingRequest} OutgoingRequest
+ * @typedef {import("../../types/imports/types").RequestOptions} RequestOptions
+ * @typedef {import("../../types/imports/types").Scheme} Scheme
+ * @typedef {import("../../types/imports/types").StatusCode} StatusCode
+ */
+
+import * as io from '@bytecodealliance/preview2-shim/io';
+import * as http from '@bytecodealliance/preview2-shim/http';
+
+export class WasiHttp {
+  requestIdBase = 1;
+  responseIdBase = 1;
+  fieldsIdBase = 1;
+  streamsIdBase = 3;
+  /** @type {Map<number,ActiveRequest>} */ requests = new Map();
+  /** @type {Map<number,ActiveResponse>} */ responses = new Map();
+  /** @type {Map<number,Map<string,string[]>>} */ fields = new Map();
+  /** @type {Map<number,Uint8Array>} */ streams = new Map();
+
+  constructor() {}
+
+  /**
+   * @param {OutgoingRequest} requestId
+   * @param {RequestOptions | null} options
+   * @returns {FutureIncomingResponse}
+   */
+  handle = (requestId, {
+    connectTimeoutMs: _connectTimeoutMs = 600_000,
+    firstByteTimeoutMs: _firstByteTimeoutMs = 600_000,
+    betweenBytesTimeoutMs: _betweenBytesTimeoutMs = 600_000
+  } = {}) => {
+    const request = this.requests.get(requestId);
+    if (!request) throw Error("not found!");
+
+    const responseId = this.responseIdBase;
+    this.responseIdBase += 1;
+    const response = new ActiveResponse(responseId);
+
+    const scheme = request.scheme.tag === "HTTP" ? "http://" : "https://";
+
+    const url = scheme + request.authority + request.path + request.query;
+    const headers = {
+      "host": request.authority,
+    };
+    for (const [key, value] of request.headers.entries()) {
+      headers[key] = Array.isArray(value) ? value.join(",") : value;
+    }
+    const body =  this.streams.get(request.body);
+
+    const res = http.send({
+      method: request.method.tag,
+      uri: url,
+      headers: headers,
+      params: [],
+      body: body && body.length > 0 ? body : undefined,
+    });
+
+    response.status = res.status;
+    for (const [key, value] of res.headers) {
+      response.responseHeaders.set(key, [value]);
+    }
+    const buf = res.body;
+    response.body = this.streamsIdBase;
+    this.streamsIdBase = this.streamsIdBase + 1;
+    this.streams.set(response.body, buf);
+    this.responses.set(responseId, response);
+    return responseId;
+  }
+
+  /**
+   * @param {InputStream} stream 
+   * @param {bigint} len 
+   * @returns {[Uint8Array | ArrayBuffer, boolean]}
+   */
+  read = (stream, len) => {
+    if (stream < 3) {
+      return io.read(stream);
+    }
+    const s = this.streams.get(stream);
+    if (!s) throw Error(`stream not found: ${stream}`);
+    const position = Number(len);
+    if (position === 0) {
+      return [new Uint8Array(), s.byteLength > 0];
+    } else if (s.byteLength > position) {
+      this.streams.set(stream, s.slice(position, s.byteLength));
+      return [s.slice(0, position), false];
+    } else {
+      return [s.slice(0, position), true];
+    }
+  }
+
+  /**
+   * @param {InputStream} stream 
+   * @returns {Pollable}
+   */
+  subscribeToInputStream = (_stream) => {
+    throw Error("unimplemented: subscribeToInputStream");
+  }
+
+  /**
+   * @param {InputStream} stream 
+   */
+  dropInputStream = (stream) => {
+    const s = this.streams.get(stream);
+    if (!s) throw Error(`no such input stream ${stream}`);
+    s.set([]);
+  }
+
+  /**
+   * @param {OutputStream} stream 
+   * @param {Uint8Array} buf 
+   * @returns {bigint}
+   */
+  write = (stream, buf) => {
+    if (stream < 3) {
+      return io.write(stream, buf);
+    }
+    this.streams.set(stream, buf);
+    return BigInt(buf.byteLength);
+  }
+
+  /**
+   * @param {OutputStream} stream 
+   * @returns {Pollable}
+   */
+  subscribeToOutputStream = (_stream) => {
+    throw Error("unimplemented: subscribeToOutputStream");
+  }
+
+  /**
+   * @param {OutputStream} stream 
+   */
+  dropOutputStream = (stream) => {
+    const s = this.streams.get(stream);
+    if (!s) throw Error(`no such output stream ${stream}`);
+    s.set([]);
+  }
+
+  /**
+   * @param {[string, string][]} entries
+   * @returns {Fields}
+   */
+  newFields = (entries) => {
+    const map = new Map(entries);
+
+    const id = this.fieldsIdBase;
+    this.fieldsIdBase = id + 1;
+    this.fields.set(id, map);
+
+    return id;
+  }
+
+  /**
+   * @param {Fields} fields
+   * @returns {[string, string][]}
+   */
+  fieldsEntries = (fields) => {
+    return this.fields.get(fields) ?? [];
+  }
+
+  /**
+   * @param {OutgoingRequest} request
+   */
+  dropOutgoingRequest = (request) => {
+    this.requests.delete(request);
+  }
+
+  /**
+   * @param {Method} method
+   * @param {string} path
+   * @param {string} query
+   * @param {Scheme | null} scheme
+   * @param {string} authority
+   * @param {Headers} headers
+   * @returns {number}
+   */
+  newOutgoingRequest = (method, path, query, scheme, authority, headers) => {
+    const id = this.requestIdBase;
+    this.requestIdBase += 1;
+
+    const req = new ActiveRequest(id);
+    req.path = path;
+    req.query = query;
+    req.authority = authority;
+    req.method = method;
+    req.headers = this.fields.get(headers);
+    req.scheme = scheme;
+    this.requests.set(id, req);
+    return id;
+  }
+  
+  /**
+   * @param {IncomingResponse} response
+   */
+  dropIncomingResponse = (response) => {
+    this.responses.delete(response);
+  }
+
+  /**
+   * @param {IncomingResponse} response
+   * @returns {StatusCode}
+   */
+  incomingResponseStatus = (response) => {
+    const r = this.responses.get(response);
+    return r.status;
+  }
+
+  /**
+   * @param {IncomingResponse} response
+   * @returns {Headers}
+   */
+  incomingResponseHeaders = (response) => {
+    const r = this.responses.get(response);
+    const id = this.fieldsIdBase;
+    this.fieldsIdBase = this.fieldsIdBase + 1;
+
+    this.fields.set(id, r.responseHeaders);
+    return id;
+  }
+
+  /**
+   * @param {IncomingResponse} response
+   * @returns {IncomingStream}
+   */
+  incomingResponseConsume = (response) => {
+    const r = this.responses.get(response);
+    return r.body;
+  }
+}
+
+class ActiveRequest {
+  /** @type {number} */ id;
+  activeRequest = false;
+  /** @type {Method} */ method = { tag: 'get' };
+  /** @type {Scheme | null} */ scheme = { tag: 'HTTP' };
+  path = "";
+  query = "";
+  authority = "";
+  /** @type {Map<string,string[]>} */ headers = new Map();
+  body = 3;
+
+  constructor(id) {
+    this.id = id;
+  }
+}
+
+class ActiveResponse {
+  /** @type {number} */ id;
+  activeResponse = false;
+  status = 0;
+  body = 3;
+  /** @type {Map<string,string[]>} */ responseHeaders = new Map();
+
+  constructor(id) {
+    this.id = id;
+  }
+}

package/lib/nodejs/environment-preopens.js

@@ -0,0 +1,3 @@
+export function preopens () {
+  return [];
+}

package/lib/nodejs/index.js

@@ -1,13 +1,16 @@
 import * as console from "./console.js";
-import * as defaultClocks from "./default-clocks.js";
 import * as defaultOutgoingHttp from "./default-outgoing-HTTP.js";
 import * as environment from "./environment.js";
+import * as environmentPreopens from "./environment-preopens.js";
 import * as exit from "./exit.js";
 import * as filesystem from "./filesystem.js";
 import * as http from "./http.js";
+import * as instanceMonotonicClock from "./instance-monotonic-clock.js";
+import * as instanceWallClock from "./instance-wall-clock.js";
 import * as io from "./io.js";
 import * as monotonicClock from "./monotonic-clock.js";
 import * as poll from "./poll.js";
+import * as preopens from "./preopens.js";
 import * as random from "./random.js";
 import * as stderr from "./stderr.js";
 import * as streams from "./streams.js";
@@ -16,15 +19,18 @@ import * as wallClock from "./wall-clock.js";
 
 export const importObject = {
     "console": console,
-    "default-clocks": defaultClocks,
     "default-outgoing-HTTP": defaultOutgoingHttp,
     "environment": environment,
+    "environment-preopens": environmentPreopens,
     "exit": exit,
     "filesystem": filesystem,
     "http": http,
+    "instance-monotonic-clock": instanceMonotonicClock,
+    "instance-wall-clock": instanceWallClock,
     "io": io,
     "monotonic-clock": monotonicClock,
     "poll": poll,
+    "preopens": preopens,
     "random": random,
     "stderr": stderr,
     "streams": streams,
@@ -32,4 +38,6 @@ export const importObject = {
     "wall-clock": wallClock,
 };
 
+export { WasiHttp } from "../http/wasi-http.js";
+
 export default importObject;

package/lib/nodejs/instance-monotonic-clock.js

@@ -0,0 +1,3 @@
+export function instanceMonotonicClock() {
+  return 0;
+}

package/lib/nodejs/instance-wall-clock.js

@@ -0,0 +1,3 @@
+export function instanceWallClock() {
+  return 1;
+}

package/lib/nodejs/io.js

@@ -1,33 +1,25 @@
-export function dropInputStream(f) {
-  console.log(`[io] Drop input stream ${f}`);
-}
-
-export function dropOutputStream(f) {
-  console.log(`[io] Drop output stream ${f}`);
-}
-
-export function read(src, len) {
-  console.log(`[io] Read ${src}`, len);
+export function read(s, len) {
+  switch (s) {
+    case 0:
+      return [process.stdin.read(len), true];
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
 }
 
-export function write(dst, buf) {
-  switch (dst) {
+export function write(s, buf) {
+  switch (s) {
     case 0:
       throw new Error(`TODO: write stdin`);
-    case 1:
+    case 1: {
       process.stdout.write(buf);
       return BigInt(buf.byteLength);
-    case 2:
-      throw new Error(`TODO: write stdout`);
+    }
+    case 2: {
+      process.stderr.write(buf);
+      return BigInt(buf.byteLength);
+    }
     default:
-      throw new Error(`TODO: write ${dst}`);
+      throw new Error(`TODO: write ${s}`);
   }
 }
-
-export function skip(src, len) {
-  console.log(`[io] Skip ${src}`, len);
-}
-
-export function write_repeated(dst, byte, len) {
-  console.log(`[io] Write repeated ${dst}`, byte, len);
-}

package/lib/nodejs/preopens.js

@@ -0,0 +1,11 @@
+export function getStdio () {
+  return {
+    stdin: 0,
+    stdout: 1,
+    stderr: 2,
+  };
+}
+
+export function getDirectories () {
+  return [];
+}

package/lib/nodejs/random.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
 
 export function getRandomBytes(len) {
-  return randomBytes(len);
+  return randomBytes(Number(len));
 }

package/lib/nodejs/streams.js

@@ -1,5 +1,10 @@
-export function read(s, _len) {
-  console.log(`[streams] Read ${s}`);
+export function read(s, len) {
+  switch (s) {
+    case 0:
+      return [process.stdin.read(len), true];
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
 }
 export function blockingRead(s, _len) {
   console.log(`[streams] Blocking read ${s}`);
@@ -16,8 +21,21 @@ export function subscribeToInputStream(s) {
 export function dropInputStream(s) {
   console.log(`[streams] Drop input stream ${s}`);
 }
-export function write(s, _buf) {
-  console.log(`[streams] Write ${s}`);
+export function write(s, buf) {
+  switch (s) {
+    case 0:
+      throw new Error(`TODO: write stdin`);
+    case 1: {
+      process.stdout.write(buf);
+      return BigInt(buf.byteLength);
+    }
+    case 2: {
+      process.stderr.write(buf);
+      return BigInt(buf.byteLength);
+    }
+    default:
+      throw new Error(`TODO: write ${s}`);
+  }
 }
 export function blockingWrite(s, _buf) {
   console.log(`[streams] Blocking write ${s}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",

package/types/imports/preopens.d.ts

@@ -0,0 +1,15 @@
+export namespace Preopens {
+  export function getStdio(): StdioPreopens;
+  export function getDirectories(): [Descriptor, string][];
+}
+import type { InputStream } from '../imports/streams';
+export { InputStream };
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };
+export interface StdioPreopens {
+  stdin: InputStream,
+  stdout: OutputStream,
+  stderr: OutputStream,
+}
+import type { Descriptor } from '../imports/filesystem';
+export { Descriptor };

package/types/wasi-reactor.d.ts

@@ -16,6 +16,7 @@ import { UdpCreateSocket as UdpCreateSocketImports } from './imports/udp-create-
 import { Random as RandomImports } from './imports/random';
 import { Environment as EnvironmentImports } from './imports/environment';
 import { EnvironmentPreopens as EnvironmentPreopensImports } from './imports/environment-preopens';
+import { Preopens as PreopensImports } from './imports/preopens';
 import { Exit as ExitImports } from './imports/exit';
 import { Stderr as StderrImports } from './imports/stderr';
 export interface ImportObject {
@@ -37,6 +38,7 @@ export interface ImportObject {
   'random': typeof RandomImports,
   'environment': typeof EnvironmentImports,
   'environment-preopens': typeof EnvironmentPreopensImports,
+  'preopens': typeof PreopensImports,
   'exit': typeof ExitImports,
   'stderr': typeof StderrImports,
 }

package/lib/browser/clocks.js

@@ -1,47 +0,0 @@
-export function wallClockNow(clock) {
-  if (clock === 1) {
-    const seconds = BigInt(Math.floor(Date.now() / 1000));
-    const nanoseconds = (Date.now() % 1000) * 1000 * 1000;
-    return { seconds, nanoseconds };
-  }
-  console.log("[clocks] UNKNOWN CLOCK");
-}
-
-export function monotonicClockResolution(clock) {
-  console.log(`[clocks] Monotonic clock resolution ${clock}`);
-}
-
-export function wallClockResolution(clock) {
-  console.log(`[clocks] Wall clock resolution ${clock}`);
-}
-
-let hrStart = hrtimeBigint();
-
-export function monotonicClockNow(clock) {
-  if (clock === 0) {
-    return hrtimeBigint() - hrStart;
-  }
-  console.log("UNKNOWN CLOCK");
-}
-
-function hrtime(previousTimestamp) {
-  const baseNow = Math.floor((Date.now() - performance.now()) * 1e-3);
-  const clocktime = performance.now() * 1e-3;
-  let seconds = Math.floor(clocktime) + baseNow;
-  let nanoseconds = Math.floor((clocktime % 1) * 1e9);
-
-  if (previousTimestamp) {
-    seconds = seconds - previousTimestamp[0];
-    nanoseconds = nanoseconds - previousTimestamp[1];
-    if (nanoseconds < 0) {
-      seconds--;
-      nanoseconds += 1e9;
-    }
-  }
-  return [seconds, nanoseconds];
-}
-
-function hrtimeBigint(time) {
-  const diff = hrtime(time);
-  return BigInt(diff[0] * 1e9 + diff[1]);
-}

package/lib/browser/default-clocks.js

@@ -1,7 +0,0 @@
-export function defaultMonotonicClock() {
-  return 0;
-}
-
-export function defaultWallClock() {
-  return 1;
-}

package/lib/nodejs/default-clocks.js

@@ -1,7 +0,0 @@
-export function defaultMonotonicClock() {
-  return 0;
-}
-
-export function defaultWallClock() {
-  return 1;
-}