@bytecodealliance/preview2-shim 0.0.13 → 0.0.15

package/README.md

@@ -10,13 +10,13 @@ Currently supports Node.js and browser versions, but alternative implementations
 | --------------- | ----------------------------:|-----------------------------:|
 | Clocks          | Pending timezone, poll       | Pending timezone, poll       |
 | Filesystem      | Basic read support           | :x:                          |
-| HTTP            | :x:                          | :x:                          |
+| HTTP            | Experimental support         | Experimental support         |
 | IO              | Basic FS Streams             | :x:                          |
 | Logging         | :heavy_check_mark:           | :heavy_check_mark:           |
 | Poll            | :x:                          | :x:                          |
 | Random          | :heavy_check_mark:           | :heavy_check_mark:           |
 | Sockets         | :x:                          | :x:                          |
-| CLI Base        | :heavy_check_mark:           | :heavy_check_mark:           |
+| CLI             | :heavy_check_mark:           | :heavy_check_mark:           |
 
 # License
 

package/lib/browser/cli.js

@@ -1,25 +1,40 @@
-let _env;
+import { _setCwd as fsSetCwd } from './filesystem.js';
+
+let _env = [], _args = [], _cwd = null;
 export function _setEnv (envObj) {
   _env = Object.entries(envObj);
 }
+export function _setArgs (args) {
+  _args = args;
+}
+
+export function _setCwd (cwd) {
+  fsSetCwd(_cwd = cwd);
+}
 
 export const environment = {
   getEnvironment () {
-    if (!_env) _env = [];
     return _env;
+  },
+  getArguments () {
+    return _args;
+  },
+  initialCwd () {
+    return _cwd;
   }
 };
 
 class ComponentExit extends Error {
-  constructor(code) {
-    super(`Component exited ${code === 0 ? 'successfully' : 'with error'}`);
-    this.code = code;
+  constructor(ok) {
+    super(`Component exited ${ok ? 'successfully' : 'with error'}`);
+    this.exitError = true;
+    this.ok = ok;
   }
 }
 
 export const exit = {
   exit (status) {
-    throw new ComponentExit(status.tag === 'err' ? 1 : 0);
+    throw new ComponentExit(status.tag === 'err' ? true : false);
   }
 };
 

package/lib/browser/filesystem.js

@@ -1,16 +1,145 @@
+import { createStream, getStream, dropStream } from './io.js';
+import { environment } from './cli.js';
+
+let _preopens = [[3, '/']], _rootPreopen = _preopens[0];
+
+export function _setPreopens (preopens) {
+  _preopens = preopens;
+  descriptorCnt = 3 + _preopens.length;
+  _rootPreopen = _preopens.find(preopen => preopen[1] === '/');
+}
+
+let _cwd = null;
+
+export function _setCwd (cwd) {
+  _cwd = cwd;
+}
+
+export function _setFileData (fileData) {
+  _fileData = fileData;
+  _setPreopens(Object.keys(fileData).map((key) => {
+    const fd = descriptorCnt++;
+    descriptorTable[fd] = { entry: fileData[key] };
+    return [fd, key];
+  }));
+  const cwd = environment.initialCwd();
+  _setCwd(cwd || '/');
+}
+
+export function _getFileData () {
+  return JSON.stringify(_fileData);
+}
+
+let _fileData = {};
+
+let descriptorCnt = 4;
+const descriptorTable = {
+  0: { stream: 0 },
+  1: { stream: 1 },
+  2: { stream: 2 },
+  3: { entry: { dir: {} } },
+};
+
+const timeZero = {
+  seconds: BigInt(0),
+  nanoseconds: 0
+};
+
+function getDescriptor (fd) {
+  const descriptor = descriptorTable[fd];
+  if (!descriptor) throw 'bad-descriptor';
+  return descriptor;
+}
+
+function getChildEntry (fd, subpath, openFlags) {
+  if (subpath === '.' && _rootPreopen && _rootPreopen[0] === fd) {
+    subpath = _cwd;
+    if (subpath.startsWith('/'))
+      subpath = subpath.slice(1);
+  }
+  let entry = getDescriptor(fd)?.entry;
+  let segmentIdx;
+  do {
+    if (!entry || !entry.dir) throw 'not-directory';
+    segmentIdx = subpath.indexOf('/');
+    const segment = segmentIdx === -1 ? subpath : subpath.slice(0, segmentIdx);
+    if (segment === '.' || segment === '') return entry;
+    if (segment === '..') throw 'no-entry';
+    if (!entry.dir[segment] && openFlags.create)
+      entry = entry.dir[segment] = openFlags.directory ? { dir: {} } : { source: new Uint8Array([]) };
+    else
+      entry = entry.dir[segment];
+  } while (segmentIdx !== -1)
+  if (!entry) throw 'no-entry';
+  return entry;
+}
+
+function createChildDescriptor (fd, subpath, openFlags) {
+  const entry = getChildEntry(fd, subpath, openFlags);
+  const childFd = descriptorCnt++;
+  descriptorTable[childFd] = { entry };
+  return childFd;
+}
+
+function getSource (fileEntry) {
+  if (typeof fileEntry.source === 'string') {
+    fileEntry.source = new TextEncoder().encode(fileEntry.source);
+  }
+  return fileEntry.source;
+}
+
+class DirStream {
+  constructor (entries) {
+    this.idx = 0;
+    this.entries = entries;
+  }
+  next () {
+    if (this.idx === this.entries.length)
+      return null;
+    const [name, entry] = this.entries[this.idx];
+    this.idx += 1;
+    return {
+      name,
+      type: entry.dir ? 'directory' : 'regular-file'
+    };
+  }
+}
+
 export const preopens = {
   getDirectories () {
-    return [];
+    return _preopens;
   }
 }
 
 export const types = {
   readViaStream(fd, offset) {
-    console.log(`[filesystem] READ STREAM ${fd} ${offset}`);
+    const descriptor = getDescriptor(fd);
+    const source = getSource(descriptor.entry);
+    return createStream({
+      i: Number(offset),
+      source,
+      read (len) {
+        const bytes = this.source.slice(this.i, this.i + Number(len));
+        this.i += bytes.byteLength;
+        return [bytes, this.i === this.source.byteLength ? 'ended' : 'open'];
+      }
+    });
   },
 
   writeViaStream(fd, offset) {
-    console.log(`[filesystem] WRITE STREAM ${fd} ${offset}`);
+    const descriptor = getDescriptor(fd);
+    return createStream({
+      i: Number(offset),
+      entry: descriptor.entry,
+      write (buf) {
+        const newSource = new Uint8Array(buf.byteLength + this.entry.source.byteLength);
+        newSource.set(this.entry.source, 0);
+        newSource.set(buf, this.i);
+        this.i += buf.byteLength;
+        this.entry.source = newSource;
+        return buf.byteLength;
+      }
+    });
   },
 
   appendViaStream(fd) {
@@ -30,7 +159,12 @@ export const types = {
   },
 
   getType(fd) {
-    console.log(`[filesystem] GET TYPE ${fd}`);
+    if (fd < 3) return 'fifo';
+    const descriptor = getDescriptor(fd);
+    if (descriptor.stream) return 'fifo';
+    if (descriptor.entry.dir) return 'directory';
+    if (descriptor.entry.source) return 'regular-file';
+    return 'unknown';
   },
 
   setFlags(fd, flags) {
@@ -46,15 +180,22 @@ export const types = {
   },
 
   read(fd, length, offset) {
-    console.log(`[filesystem] READ`, fd, length, offset);
+    const descriptor = getDescriptor(fd);
+    const source = getSource(descriptor.entry);
+    return [source.slice(offset, offset + length), offset + length >= source.byteLength];
   },
 
   write(fd, buffer, offset) {
-    console.log(`[filesystem] WRITE`, fd, buffer, offset);
+    const descriptor = getDescriptor(fd);
+    if (offset !== 0) throw 'invalid-seek';
+    descriptor.entry.source = buffer;
+    return buffer.byteLength;
   },
 
   readDirectory(fd) {
-    console.log(`[filesystem] READ DIR`, fd);
+    const descriptor = getDescriptor(fd);
+    if (!descriptor?.entry?.dir) throw 'bad-descriptor';
+    return createStream(new DirStream(Object.entries(descriptor.entry.dir).sort(([a], [b]) => a > b ? 1 : -1)));
   },
 
   sync(fd) {
@@ -62,15 +203,50 @@ export const types = {
   },
 
   createDirectoryAt(fd, path) {
-    console.log(`[filesystem] CREATE DIRECTORY`, fd, path);
+    const entry = getChildEntry(fd, path, { create: true, directory: true });
+    if (entry.source) throw 'exist';
   },
 
   stat(fd) {
-    console.log(`[filesystem] STAT`, fd);
+    const descriptor = getDescriptor(fd);
+    let type = 'unknown', size = BigInt(0);
+    if (descriptor.entry.source) {
+      type = 'directory';
+    }
+    else if (descriptor.entry.dir) {
+      type = 'regular-file';
+      const source = getSource(descriptor.entry);
+      size = BigInt(source.byteLength);
+    }
+    return {
+      type,
+      linkCount: BigInt(0),
+      size,
+      dataAccessTimestamp: timeZero,
+      dataModificationTimestamp: timeZero,
+      statusChangeTimestamp: timeZero,
+    }
   },
   
   statAt(fd, pathFlags, path) {
-    console.log(`[filesystem] STAT`, fd, pathFlags, path);
+    const entry = getChildEntry(fd, path);
+    let type = 'unknown', size = BigInt(0);
+    if (entry.source) {
+      type = 'regular-file';
+      const source = getSource(entry);
+      size = BigInt(source.byteLength);
+    }
+    else if (entry.dir) {
+      type = 'directory';
+    }
+    return {
+      type,
+      linkCount: BigInt(0),
+      size,
+      dataAccessTimestamp: timeZero,
+      dataModificationTimestamp: timeZero,
+      statusChangeTimestamp: timeZero,
+    };
   },
 
   setTimesAt(fd) {
@@ -81,8 +257,8 @@ export const types = {
     console.log(`[filesystem] LINK AT`, fd);
   },
 
-  openAt(fd) {
-    console.log(`[filesystem] OPEN AT ${fd}`);
+  openAt(fd, _pathFlags, path, openFlags, _descriptorFlags, _modes) {
+    return createChildDescriptor(fd, path, openFlags);
   },
 
   readlinkAt(fd) {
@@ -134,23 +310,31 @@ export const types = {
   },
 
   dropDescriptor(fd) {
-    console.log(`[filesystem] DROP DESCRIPTOR`, fd);
+    if (fd < _preopens.length + 3)
+      return;
+    delete descriptorTable[fd];
   },
 
-  readDirectoryEntry(stream) {
-    console.log(`[filesystem] READ DIRECTRY ENTRY`, stream);
+  readDirectoryEntry(sid) {
+    return getStream(sid).next();
   },
 
-  dropDirectoryEntryStream(stream) {
-    console.log(`[filesystem] DROP DIRECTORY ENTRY`, stream);
+  dropDirectoryEntryStream(sid) {
+    dropStream(sid);
   },
 
   metadataHash(fd) {
-    console.log(`[filesystem] METADATA HASH`, fd);
+    const descriptor = getDescriptor(fd);
+    let upper = BigInt(0);
+    upper += BigInt(descriptor.mtime || 0);
+    return { upper, lower: BigInt(0) };
   },
 
-  metadataHashAt(fd, pathFlags, path) {
-    console.log(`[filesystem] METADATA HASH AT `, fd, pathFlags, path);
+  metadataHashAt(fd, _pathFlags, _path) {
+    const descriptor = getDescriptor(fd);
+    let upper = BigInt(0);
+    upper += BigInt(descriptor.mtime || 0);
+    return { upper, lower: BigInt(0) };
   }
 };
 

package/lib/browser/http.js

@@ -1,7 +1,7 @@
 import { UnexpectedError } from "../http/error.js";
 
 /**
- * @param {import("../types/imports/types").Request} req
+ * @param {import("../../types/interfaces/wasi-http-types").Request} req
  * @returns {string}
  */
 export function send(req) {
@@ -86,11 +86,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");
@@ -104,7 +101,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/browser/io.js

@@ -1,9 +1,81 @@
+// buffer until the next newline
+class NewlineBufferStream {
+  constructor (handler) {
+    this.bufferLen = 0;
+    this.bufferCapacity = 1024;
+    this.buffer = new Uint8Array(1024);
+    this.handler = handler;
+  }
+  write (bytes) {
+    const newlineIdx = bytes.lastIndexOf(10);
+    if (newlineIdx === -1) {
+      this.#addToBuffer(bytes);
+    } else {
+      this.#addToBuffer(bytes.slice(0, newlineIdx + 1));
+      this.handler(new TextDecoder().decode(this.buffer.slice(0, this.bufferLen)));
+      this.bufferLen = 0;
+      this.#addToBuffer(bytes.slice(newlineIdx + 1));
+    }
+  }
+  #addToBuffer (bytes) {
+    if (bytes.byteLength + this.bufferLen > this.bufferCapacity) {
+      this.bufferCapacity *= 2;
+      const buffer = new Uint8Array(this.bufferCapacity);
+      buffer.set(this.buffer);
+      this.buffer = buffer;
+    }
+    this.buffer.set(bytes, this.bufferLen);
+    this.bufferLen += bytes.byteLength;
+  }
+}
+
+class IgnoreStream {
+  read () {
+    return [new Uint8Array([]), 'ended'];
+  }
+  write () {}
+}
+
+export function createStream (stream) {
+  streamEntries[streamCnt] = stream;
+  return streamCnt++;
+}
+
+export function getStream (sid) {
+  const stream = streamEntries[sid];
+  if (!stream) throw new Error();
+  return stream;
+}
+
+export function dropStream (sid) {
+  delete streamEntries[sid];
+}
+
+let streamCnt = 3;
+const streamEntries = {
+  0: new IgnoreStream(),
+  1: new NewlineBufferStream(console.log.bind(console)),
+  2: new NewlineBufferStream(console.error.bind(console)),
+};
+
+export function _setStdout (stdout) {
+  streamEntries[1] = stdout;
+}
+
+export function _setStderr (stderr) {
+  streamEntries[2] = stderr;
+}
+
+export function _setStdin (stdin) {
+  streamEntries[0] = stdin;
+}
+
 export const streams = {
   read(s, len) {
-    console.log(`[streams] Read ${s} ${len}`);
+    return getStream(s).read(len);
   },
   blockingRead(s, len) {
-    console.log(`[streams] Blocking read ${s} ${len}`);
+    return getStream(s).read(len);
   },
   skip(s, _len) {
     console.log(`[streams] Skip ${s}`);
@@ -17,24 +89,22 @@ export const streams = {
   dropInputStream(s) {
     console.log(`[streams] Drop input stream ${s}`);
   },
+  checkWrite(_s) {
+    // TODO: implement
+    return 1000000n;
+  },
   write(s, buf) {
-    streams.blockingWrite(s, buf);
-  },
-  blockingWrite(s, buf) {
-    switch (s) {
-      case 0:
-        throw new Error(`TODO: write stdin`);
-      case 1: {
-        process.stdout.write(buf);
-        return [BigInt(buf.byteLength), 'ended'];
-      }
-      case 2: {
-        process.stderr.write(buf);
-        return [BigInt(buf.byteLength), 'ended'];
-      }
-      default:
-        throw new Error(`TODO: write ${s}`);
-    }
+    getStream(s).write(buf);
+  },
+  blockingWriteAndFlush(s, buf) {
+    // TODO: implement
+    return streams.write(s, buf);
+  },
+  flush(s) {
+    return streams.blockingFlush(s);
+  },
+  blockingFlush(_s) {
+    // TODO: implement
   },
   writeZeroes(s, _len) {
     console.log(`[streams] Write zeroes ${s}`);

package/lib/browser/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;
     console[level](`(${context}) ${msg}\n`);

package/lib/browser/poll.js

@@ -1,9 +1,53 @@
+let polls = {};
+let pollCnt = 1;
+
+let timer = null, timerInterval = 10, watching = new Set();
+function intervalCheck () {
+  for (const entry of watching) {
+    if (entry.settled) {
+      entry.resolvePromise();
+      entry.promise = entry.resolvePromise = null;
+      watching.delete(entry);
+    }
+  }
+  if (watching.size === 0) {
+    clearInterval(timer);
+    timer = null;
+  }
+}
+
+export function _createPollable (promise) {
+  const entry = { settled: false, promise: null, resolvePromise: null };
+  promise.finally(() => entry.settled = true);
+  polls[pollCnt] = entry;
+  return pollCnt++;
+}
+
+export function _pollablePromise (pollable, maxInterval) {
+  const entry = polls[pollable];
+  if (entry.settled) return Promise.resolve();
+  if (!entry.promise)
+    entry.promise = new Promise(resolve => entry.resolvePromise = resolve);
+  watching.add(entry);
+  if (maxInterval) {
+    if (timerInterval > maxInterval) {
+      clearInterval(timer);
+      timer = null;
+      timerInterval = maxInterval;
+    }
+  }
+  if (!timer)
+    timer = setInterval(intervalCheck, timerInterval);
+  return entry.promise;
+}
+
 export const poll = {
   dropPollable (pollable) {
-    console.log(`[poll] Drop (${pollable})`);
+    const entry = polls[pollable];
+    watching.delete(entry);
+    delete polls[pollable];
   },
-  pollOneoff (input) {
-    console.log(`[poll] Oneoff (${input})`);
-    return [];
+  pollOneoff (from) {
+    return from.map(pollable => polls[pollable].settled);
   }
 };

package/lib/http/error.js

@@ -1,5 +1,5 @@
 export class UnexpectedError extends Error {
-  /** @type { import("../types/http").HttpErrorUnexpectedError } */
+  /** @type { import("../../types/interfaces/wasi-http-types").ErrorUnexpectedError } */
   payload;
   constructor(message = "unexpected-error") {
     super(message);

package/lib/http/make-request.js

@@ -1,7 +1,7 @@
 import { runAsWorker } from "./synckit/index.js";
 
 /**
- * @param {import("../types/imports/types").Request} req
+ * @param {import("../../types/interfaces/wasi-http-types").Request} req
  * @returns {Promise<string>}
  */
 async function makeRequest(req) {
@@ -11,18 +11,19 @@ async function makeRequest(req) {
       method: req.method.toString(),
       headers,
       body: req.body && req.body.length > 0 ? req.body : undefined,
+      redirect: "manual",
     });
     let arrayBuffer = await resp.arrayBuffer();
     return JSON.stringify({
       status: resp.status,
-      headers: Array.from(resp.headers.entries()),
+      headers: Array.from(resp.headers),
       body:
         arrayBuffer.byteLength > 0
           ? Buffer.from(arrayBuffer).toString("base64")
           : undefined,
     });
   } catch (err) {
-    return err.message;
+    return JSON.stringify({ message: err.toString() });
   }
 }