@bytecodealliance/preview2-shim 0.0.13 → 0.0.14

package/lib/http/wasi-http.js

@@ -1,18 +1,19 @@
 // Based on:
-// https://github.com/bytecodealliance/wasmtime/blob/76eb40e0756d90cc9c16b26a8d8b1e0ebf75f44d/crates/wasi-http/src/http_impl.rs
+// https://github.com/bytecodealliance/wasmtime/blob/8efcb9851602287fd07a1a1e91501f51f2653d7e/crates/wasi-http/
 
 /**
- * @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").Result} Result
- * @typedef {import("../../types/imports/types").Scheme} Scheme
- * @typedef {import("../../types/imports/types").StatusCode} StatusCode
+ * @typedef {import("../../types/imports/wasi-http-types").Fields} Fields
+ * @typedef {import("../../types/imports/wasi-http-types").FutureIncomingResponse} FutureIncomingResponse
+ * @typedef {import("../../types/imports/wasi-http-types").Headers} Headers
+ * @typedef {import("../../types/imports/wasi-http-types").IncomingResponse} IncomingResponse
+ * @typedef {import("../../types/imports/wasi-http-types").IncomingStream} IncomingStream
+ * @typedef {import("../../types/imports/wasi-http-types").Method} Method
+ * @typedef {import("../../types/imports/wasi-http-types").OutgoingRequest} OutgoingRequest
+ * @typedef {import("../../types/imports/wasi-http-types").RequestOptions} RequestOptions
+ * @typedef {import("../../types/imports/wasi-http-types").Result} Result
+ * @typedef {import("../../types/imports/wasi-http-types").Scheme} Scheme
+ * @typedef {import("../../types/imports/wasi-http-types").StatusCode} StatusCode
+ * @typedef {import("../../types/imports/wasi-io-streams").StreamStatus} StreamStatus
 */
 
 import * as io from '@bytecodealliance/preview2-shim/io';
@@ -48,12 +49,14 @@ export class WasiHttp {
 
     const scheme = request.scheme.tag === "HTTP" ? "http://" : "https://";
 
-    const url = scheme + request.authority + request.path + request.query;
+    const url = scheme + request.authority + request.pathWithQuery;
     const headers = {
       "host": request.authority,
     };
-    for (const [key, value] of request.headers.entries()) {
-      headers[key] = Array.isArray(value) ? value.join(",") : value;
+    if (request.headers && request.headers.size > 0) {
+      for (const [key, value] of request.headers.entries()) {
+        headers[key] = Array.isArray(value) ? value.join(",") : value;
+      }
     }
     const body =  this.streams.get(request.body);
 
@@ -66,8 +69,10 @@ export class WasiHttp {
     });
 
     response.status = res.status;
-    for (const [key, value] of res.headers) {
-      response.responseHeaders.set(key, [value]);
+    if (res.headers && res.headers.size > 0) {
+      for (const [key, value] of res.headers) {
+        response.responseHeaders.set(key, [value]);
+      }
     }
     const buf = res.body;
     response.body = this.streamIdBase;
@@ -82,25 +87,29 @@ export class WasiHttp {
     return futureId;
   }
 
+  read = (stream, len) => {
+    return this.blockingRead(stream, len);
+  }
+
   /**
    * @param {InputStream} stream 
    * @param {bigint} len 
-   * @returns {[Uint8Array | ArrayBuffer, boolean]}
+   * @returns {[Uint8Array | ArrayBuffer, StreamStatus]}
    */
-  read = (stream, len) => {
+  blockingRead = (stream, len) => {
     if (stream < 3) {
-      return io.read(stream);
+      return io.streams.blockingRead(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];
+      return [new Uint8Array(), s.byteLength > 0 ? 'open' : 'ended'];
     } else if (s.byteLength > position) {
       this.streams.set(stream, s.slice(position, s.byteLength));
-      return [s.slice(0, position), false];
+      return [s.slice(0, position), 'open'];
     } else {
-      return [s.slice(0, position), true];
+      return [s.slice(0, position), 'ended'];
     }
   }
 
@@ -108,8 +117,9 @@ export class WasiHttp {
    * @param {InputStream} stream 
    * @returns {Pollable}
    */
-  subscribeToInputStream = (_stream) => {
-    throw Error("unimplemented: subscribeToInputStream");
+  subscribeToInputStream = (stream) => {
+    // TODO: not implemented yet
+    console.log(`[streams] Subscribe to input stream ${stream}`);
   }
 
   /**
@@ -121,25 +131,30 @@ export class WasiHttp {
     s.set([]);
   }
 
+  write = (stream, buf) => {
+    return this.blockingWrite(stream, buf);
+  }
+
   /**
    * @param {OutputStream} stream 
    * @param {Uint8Array} buf 
-   * @returns {bigint}
+   * @returns {[bigint, StreamStatus]}
    */
-  write = (stream, buf) => {
+  blockingWrite = (stream, buf) => {
     if (stream < 3) {
-      return io.write(stream, buf);
+      return io.streams.blockingWrite(stream, buf);
     }
     this.streams.set(stream, buf);
-    return BigInt(buf.byteLength);
+    return [BigInt(buf.byteLength), 'ended'];
   }
 
   /**
    * @param {OutputStream} stream 
    * @returns {Pollable}
    */
-  subscribeToOutputStream = (_stream) => {
-    throw Error("unimplemented: subscribeToOutputStream");
+  subscribeToOutputStream = (stream) => {
+    // TODO: not implemented yet
+    console.log(`[streams] Subscribe to output stream ${stream}`);
   }
 
   /**
@@ -189,20 +204,18 @@ export class WasiHttp {
 
   /**
    * @param {Method} method
-   * @param {string} path
-   * @param {string} query
+   * @param {string | null} pathWithQuery
    * @param {Scheme | null} scheme
-   * @param {string} authority
+   * @param {string | null} authority
    * @param {Headers} headers
    * @returns {number}
    */
-  newOutgoingRequest = (method, path, query, scheme, authority, headers) => {
+  newOutgoingRequest = (method, pathWithQuery, scheme, authority, headers) => {
     const id = this.requestIdBase;
     this.requestIdBase += 1;
 
     const req = new ActiveRequest(id);
-    req.path = path;
-    req.query = query;
+    req.pathWithQuery = pathWithQuery;
     req.authority = authority;
     req.method = method;
     req.headers = this.fields.get(headers);
@@ -301,9 +314,8 @@ class ActiveRequest {
   activeRequest = false;
   /** @type {Method} */ method = { tag: 'get' };
   /** @type {Scheme | null} */ scheme = { tag: 'HTTP' };
-  path = "";
-  query = "";
-  authority = "";
+  pathWithQuery = null;
+  authority = null;
   /** @type {Map<string,string[]>} */ headers = new Map();
   body = 3;
 

package/lib/nodejs/cli.js

@@ -1,12 +1,26 @@
-let _env;
+let _env, _args = [], _cwd = null;
 export function _setEnv (envObj) {
   _env = Object.entries(envObj);
 }
 
+export function _setArgs (args) {
+  _args = args;
+}
+
+export function _setCwd (cwd) {
+  _cwd = cwd;
+}
+
 export const environment = {
   getEnvironment () {
     if (!_env) _setEnv(process.env);
     return _env;
+  },
+  getArguments () {
+    return _args;
+  },
+  initialCwd () {
+    return _cwd;
   }
 };
 
@@ -35,15 +49,11 @@ export const stderr = {
 };
 
 export const terminalInput = {
-  dropTerminalInput () {
-
-  }
+  dropTerminalInput () {}
 };
 
 export const terminalOutput = {
-  dropTerminalOutput () {
-
-  }
+  dropTerminalOutput () {}
 };
 
 export const terminalStderr = {

package/lib/nodejs/http.js

@@ -15,7 +15,7 @@ export function send(req) {
       body: response.body ? Buffer.from(response.body, "base64") : undefined,
     };
   }
-  throw new UnexpectedError(response);
+  throw new UnexpectedError(response.message);
 }
 
 export const incomingHandler = {
@@ -70,11 +70,8 @@ export const types = {
   incomingRequestMethod(_req) {
     console.log("[types] Incoming request method");
   },
-  incomingRequestPath(_req) {
-    console.log("[types] Incoming request path");
-  },
-  incomingRequestQuery(_req) {
-    console.log("[types] Incoming request query");
+  incomingRequestPathWithQuery(_req) {
+    console.log("[types] Incoming request path with query");
   },
   incomingRequestScheme(_req) {
     console.log("[types] Incoming request scheme");
@@ -88,7 +85,7 @@ export const types = {
   incomingRequestConsume(_req) {
     console.log("[types] Incoming request consume");
   },
-  newOutgoingRequest(_method, _path, _query, _scheme, _authority, _headers) {
+  newOutgoingRequest(_method, _pathWithQuery, _scheme, _authority, _headers) {
     console.log("[types] New outgoing request");
   },
   outgoingRequestWrite(_req) {

package/lib/nodejs/logging.js

@@ -1,8 +1,8 @@
-const levels = ["trace", "debug", "info", "warn", "error"];
+const levels = ["trace", "debug", "info", "warn", "error", "critical"];
 
 let logLevel = levels.indexOf("warn");
 
-export const handler = {
+export const logging = {
   log(level, context, msg) {
     if (logLevel > levels.indexOf(level)) return;
     process.stdout.write(`${level}: (${context}) ${msg}\n`);

package/package.json

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

package/types/exports/wasi-cli-environment.d.ts

@@ -0,0 +1,22 @@
+export namespace WasiCliEnvironment {
+  /**
+   * Get the POSIX-style environment variables.
+   * 
+   * Each environment variable is provided as a pair of string variable names
+   * and string value.
+   * 
+   * Morally, these are a value import, but until value imports are available
+   * in the component model, this import function should return the same
+   * values each time it is called.
+   */
+  export function getEnvironment(): [string, string][];
+  /**
+   * Get the POSIX-style arguments to the program.
+   */
+  export function getArguments(): string[];
+  /**
+   * Return a path that programs should use as their initial current working
+   * directory, interpreting `.` as shorthand for this.
+   */
+  export function initialCwd(): string | null;
+}

package/types/exports/wasi-cli-exit.d.ts

@@ -0,0 +1,7 @@
+export namespace WasiCliExit {
+  /**
+   * Exit the current instance and any linked instances.
+   */
+  export function exit(status: Result<void, void>): void;
+}
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/types/exports/wasi-cli-run.d.ts

@@ -0,0 +1,6 @@
+export namespace WasiCliRun {
+  /**
+   * Run the program.
+   */
+  export function run(): void;
+}

package/types/exports/wasi-cli-stderr.d.ts

@@ -0,0 +1,5 @@
+export namespace WasiCliStderr {
+  export function getStderr(): OutputStream;
+}
+import type { OutputStream } from '../exports/wasi-io-streams';
+export { OutputStream };

package/types/exports/wasi-cli-stdin.d.ts

@@ -0,0 +1,5 @@
+export namespace WasiCliStdin {
+  export function getStdin(): InputStream;
+}
+import type { InputStream } from '../exports/wasi-io-streams';
+export { InputStream };

package/types/exports/wasi-cli-stdout.d.ts

@@ -0,0 +1,5 @@
+export namespace WasiCliStdout {
+  export function getStdout(): OutputStream;
+}
+import type { OutputStream } from '../exports/wasi-io-streams';
+export { OutputStream };

package/types/exports/wasi-cli-terminal-input.d.ts

@@ -0,0 +1,13 @@
+export namespace WasiCliTerminalInput {
+  /**
+   * Dispose of the specified terminal-input after which it may no longer
+   * be used.
+   */
+  export function dropTerminalInput(this_: TerminalInput): void;
+}
+/**
+ * The input side of a terminal.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type TerminalInput = number;

package/types/exports/wasi-cli-terminal-output.d.ts

@@ -0,0 +1,13 @@
+export namespace WasiCliTerminalOutput {
+  /**
+   * Dispose of the specified terminal-output, after which it may no longer
+   * be used.
+   */
+  export function dropTerminalOutput(this_: TerminalOutput): void;
+}
+/**
+ * The output side of a terminal.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type TerminalOutput = number;

package/types/exports/wasi-cli-terminal-stderr.d.ts

@@ -0,0 +1,9 @@
+export namespace WasiCliTerminalStderr {
+  /**
+   * If stderr is connected to a terminal, return a `terminal-output` handle
+   * allowing further interaction with it.
+   */
+  export function getTerminalStderr(): TerminalOutput | null;
+}
+import type { TerminalOutput } from '../exports/wasi-cli-terminal-output';
+export { TerminalOutput };

package/types/exports/wasi-cli-terminal-stdin.d.ts

@@ -0,0 +1,9 @@
+export namespace WasiCliTerminalStdin {
+  /**
+   * If stdin is connected to a terminal, return a `terminal-input` handle
+   * allowing further interaction with it.
+   */
+  export function getTerminalStdin(): TerminalInput | null;
+}
+import type { TerminalInput } from '../exports/wasi-cli-terminal-input';
+export { TerminalInput };

package/types/exports/wasi-cli-terminal-stdout.d.ts

@@ -0,0 +1,9 @@
+export namespace WasiCliTerminalStdout {
+  /**
+   * If stdout is connected to a terminal, return a `terminal-output` handle
+   * allowing further interaction with it.
+   */
+  export function getTerminalStdout(): TerminalOutput | null;
+}
+import type { TerminalOutput } from '../exports/wasi-cli-terminal-output';
+export { TerminalOutput };

package/types/exports/wasi-clocks-monotonic-clock.d.ts

@@ -0,0 +1,24 @@
+export namespace WasiClocksMonotonicClock {
+  /**
+   * Read the current value of the clock.
+   * 
+   * The clock is monotonic, therefore calling this function repeatedly will
+   * produce a sequence of non-decreasing values.
+   */
+  export function now(): Instant;
+  /**
+   * Query the resolution of the clock.
+   */
+  export function resolution(): Instant;
+  /**
+   * Create a `pollable` which will resolve once the specified time has been
+   * reached.
+   */
+  export function subscribe(when: Instant, absolute: boolean): Pollable;
+}
+import type { Pollable } from '../exports/wasi-poll-poll';
+export { Pollable };
+/**
+ * A timestamp in nanoseconds.
+ */
+export type Instant = bigint;

package/types/exports/wasi-clocks-timezone.d.ts

@@ -0,0 +1,71 @@
+export namespace WasiClocksTimezone {
+  /**
+   * Return information needed to display the given `datetime`. This includes
+   * the UTC offset, the time zone name, and a flag indicating whether
+   * daylight saving time is active.
+   * 
+   * If the timezone cannot be determined for the given `datetime`, return a
+   * `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight
+   * saving time.
+   */
+  export function display(this_: Timezone, when: Datetime): TimezoneDisplay;
+  /**
+   * The same as `display`, but only return the UTC offset.
+   */
+  export function utcOffset(this_: Timezone, when: Datetime): number;
+  /**
+   * Dispose of the specified input-stream, after which it may no longer
+   * be used.
+   */
+  export function dropTimezone(this_: Timezone): void;
+}
+import type { Datetime } from '../exports/wasi-clocks-wall-clock';
+export { Datetime };
+/**
+ * A timezone.
+ * 
+ * In timezones that recognize daylight saving time, also known as daylight
+ * time and summer time, the information returned from the functions varies
+ * over time to reflect these adjustments.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type Timezone = number;
+/**
+ * Information useful for displaying the timezone of a specific `datetime`.
+ * 
+ * This information may vary within a single `timezone` to reflect daylight
+ * saving time adjustments.
+ */
+export interface TimezoneDisplay {
+  /**
+   * The number of seconds difference between UTC time and the local
+   * time of the timezone.
+   * 
+   * The returned value will always be less than 86400 which is the
+   * number of seconds in a day (24*60*60).
+   * 
+   * In implementations that do not expose an actual time zone, this
+   * should return 0.
+   */
+  utcOffset: number,
+  /**
+   * The abbreviated name of the timezone to display to a user. The name
+   * `UTC` indicates Coordinated Universal Time. Otherwise, this should
+   * reference local standards for the name of the time zone.
+   * 
+   * In implementations that do not expose an actual time zone, this
+   * should be the string `UTC`.
+   * 
+   * In time zones that do not have an applicable name, a formatted
+   * representation of the UTC offset may be returned, such as `-04:00`.
+   */
+  name: string,
+  /**
+   * Whether daylight saving time is active.
+   * 
+   * In implementations that do not expose an actual time zone, this
+   * should return false.
+   */
+  inDaylightSavingTime: boolean,
+}

package/types/exports/wasi-clocks-wall-clock.d.ts

@@ -0,0 +1,31 @@
+export namespace WasiClocksWallClock {
+  /**
+   * Read the current value of the clock.
+   * 
+   * This clock is not monotonic, therefore calling this function repeatedly
+   * will not necessarily produce a sequence of non-decreasing values.
+   * 
+   * The returned timestamps represent the number of seconds since
+   * 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+   * also known as [Unix Time].
+   * 
+   * The nanoseconds field of the output is always less than 1000000000.
+   * 
+   * [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+   * [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+   */
+  export function now(): Datetime;
+  /**
+   * Query the resolution of the clock.
+   * 
+   * The nanoseconds field of the output is always less than 1000000000.
+   */
+  export function resolution(): Datetime;
+}
+/**
+ * A time and date in seconds plus nanoseconds.
+ */
+export interface Datetime {
+  seconds: bigint,
+  nanoseconds: number,
+}

package/types/exports/wasi-filesystem-preopens.d.ts

@@ -0,0 +1,8 @@
+export namespace WasiFilesystemPreopens {
+  /**
+   * Return the set of preopened directories, and their path.
+   */
+  export function getDirectories(): [Descriptor, string][];
+}
+import type { Descriptor } from '../exports/wasi-filesystem-types';
+export { Descriptor };