typescript-virtual-container 1.5.0 → 1.5.2

package/polyfills/node_crypto/index.js

@@ -1,7 +1,167 @@
-// Minimal crypto shim using Web Crypto where possible; fallback simple hashes.
-export function randomBytes(n){ const a=new Uint8Array(n); crypto.getRandomValues(a); return a; }
-export function randomUUID(){ return crypto.randomUUID ? crypto.randomUUID() : Math.floor(Math.random()*1e9).toString(16); }
-export function createHash(alg){ let data=''; return { update(d){ data += String(d); return this; }, digest(enc='hex'){ // simple hash fallback
-    let h=0; for(let i=0;i<data.length;i++) h=(h*31+data.charCodeAt(i))|0; const s=(h>>>0).toString(16); return enc==='hex'?s:s; } }; }
-export function scryptSync(){ throw new Error('scryptSync not implemented in browser shim'); }
-export default { randomBytes, randomUUID, createHash, scryptSync };
+// ─── SHA-256 (pure JS) ───────────────────────────────────────────────────────
+const K = new Uint32Array([
+  0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
+  0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
+  0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
+  0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
+  0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
+  0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
+  0x19a4c116,0x1e376c085,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
+  0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
+]);
+
+function sha256(data) {
+  const msg = data instanceof Uint8Array ? data : new TextEncoder().encode(data);
+  const bits = msg.length * 8;
+  const padLen = Math.ceil((msg.length + 9) / 64) * 64;
+  const padded = new Uint8Array(padLen);
+  padded.set(msg);
+  padded[msg.length] = 0x80;
+  const dv0 = new DataView(padded.buffer);
+  dv0.setUint32(padLen - 4, bits >>> 0, false);
+
+  let h0=0x6a09e667, h1=0xbb67ae85, h2=0x3c6ef372, h3=0xa54ff53a,
+      h4=0x510e527f, h5=0x9b05688c, h6=0x1f83d9ab, h7=0x5be0cd19;
+
+  const w = new Uint32Array(64);
+  const dv = new DataView(padded.buffer);
+  for (let i = 0; i < padLen; i += 64) {
+    for (let j = 0; j < 16; j++) w[j] = dv.getUint32(i + j * 4, false);
+    for (let j = 16; j < 64; j++) {
+      const s0 = (w[j-15]>>>7|w[j-15]<<25)^(w[j-15]>>>18|w[j-15]<<14)^(w[j-15]>>>3);
+      const s1 = (w[j-2]>>>17|w[j-2]<<15)^(w[j-2]>>>19|w[j-2]<<13)^(w[j-2]>>>10);
+      w[j] = (w[j-16] + s0 + w[j-7] + s1) | 0;
+    }
+    let a=h0,b=h1,c=h2,d=h3,e=h4,f=h5,g=h6,hh=h7;
+    for (let j = 0; j < 64; j++) {
+      const S1  = (e>>>6|e<<26)^(e>>>11|e<<21)^(e>>>25|e<<7);
+      const ch  = (e&f)^(~e&g);
+      const t1  = (hh + S1 + ch + K[j] + w[j]) | 0;
+      const S0  = (a>>>2|a<<30)^(a>>>13|a<<19)^(a>>>22|a<<10);
+      const maj = (a&b)^(a&c)^(b&c);
+      const t2  = (S0 + maj) | 0;
+      hh=g; g=f; f=e; e=(d+t1)|0; d=c; c=b; b=a; a=(t1+t2)|0;
+    }
+    h0=(h0+a)|0; h1=(h1+b)|0; h2=(h2+c)|0; h3=(h3+d)|0;
+    h4=(h4+e)|0; h5=(h5+f)|0; h6=(h6+g)|0; h7=(h7+hh)|0;
+  }
+
+  const out = new Uint8Array(32);
+  const odv = new DataView(out.buffer);
+  [h0,h1,h2,h3,h4,h5,h6,h7].forEach((v,i) => odv.setUint32(i*4, v, false));
+  return out;
+}
+
+// ─── HMAC-SHA256 ─────────────────────────────────────────────────────────────
+function hmacSha256(key, data) {
+  const BLOCK = 64;
+  let k = key instanceof Uint8Array ? key : new TextEncoder().encode(key);
+  if (k.length > BLOCK) k = sha256(k);
+  const kpad = new Uint8Array(BLOCK);
+  kpad.set(k);
+  const ipad = kpad.map(b => b ^ 0x36);
+  const opad = kpad.map(b => b ^ 0x5c);
+  const inner = new Uint8Array(BLOCK + data.length);
+  inner.set(ipad); inner.set(data, BLOCK);
+  const outer = new Uint8Array(BLOCK + 32);
+  outer.set(opad); outer.set(sha256(inner), BLOCK);
+  return sha256(outer);
+}
+
+// ─── PBKDF2-HMAC-SHA256 (sync) ───────────────────────────────────────────────
+function pbkdf2Sync(password, salt, iterations, keylen) {
+  const pw   = password instanceof Uint8Array ? password : new TextEncoder().encode(password);
+  const sl   = salt instanceof Uint8Array ? salt : new TextEncoder().encode(salt);
+  const hlen = 32;
+  const blocks = Math.ceil(keylen / hlen);
+  const dk = new Uint8Array(keylen);
+
+  for (let i = 1; i <= blocks; i++) {
+    const ibuf = new Uint8Array(4);
+    new DataView(ibuf.buffer).setUint32(0, i, false);
+    const saltI = new Uint8Array(sl.length + 4);
+    saltI.set(sl);
+    saltI.set(ibuf, sl.length);
+
+    let U = hmacSha256(pw, saltI);
+    const T = new Uint8Array(U);
+    for (let j = 1; j < iterations; j++) {
+      U = hmacSha256(pw, U);
+      for (let k = 0; k < hlen; k++) T[k] ^= U[k];
+    }
+    const offset = (i - 1) * hlen;
+    dk.set(T.slice(0, keylen - offset), offset);
+  }
+  return dk;
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+export function randomBytes(n) {
+  const a = new Uint8Array(n);
+  crypto.getRandomValues(a);
+  return a;
+}
+
+export function randomUUID() {
+  return crypto.randomUUID
+    ? crypto.randomUUID()
+    : ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
+        (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
+}
+
+export function createHash(alg) {
+  const chunks = [];
+  return {
+    update(d) {
+      chunks.push(d instanceof Uint8Array ? d : new TextEncoder().encode(String(d)));
+      return this;
+    },
+    digest(enc = 'hex') {
+      const total = chunks.reduce((s, c) => s + c.length, 0);
+      const buf = new Uint8Array(total);
+      let off = 0;
+      for (const c of chunks) { buf.set(c, off); off += c.length; }
+      const hash = sha256(buf);
+      if (enc === 'hex') return Array.from(hash).map(b => b.toString(16).padStart(2,'0')).join('');
+      if (enc === 'base64') return btoa(String.fromCharCode(...hash));
+      return hash;
+    },
+  };
+}
+
+export function scryptSync(password, salt, keylen, options = {}) {
+  const N = options.N ?? 16384;
+  const iterations = Math.max(1000, Math.round(Math.log2(N) * 1000));
+  const pw = typeof password === 'string' ? new TextEncoder().encode(password) : password;
+  const sl = typeof salt === 'string' ? new TextEncoder().encode(salt) : salt;
+  return pbkdf2Sync(pw, sl, iterations, keylen);
+}
+
+export function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+
+export function generateKeyPairSync() {
+  throw new Error('generateKeyPairSync is not implemented in this environment');
+}
+
+export function createHmac() {
+  throw new Error('createHmac is not implemented in this environment');
+}
+
+export function createCipheriv() {
+  throw new Error('createCipheriv is not implemented in this environment');
+}
+
+export function createDecipheriv() {
+  throw new Error('createDecipheriv is not implemented in this environment');
+}
+
+export function createSign() {
+  throw new Error('createSign is not implemented in this environment');
+}
+
+export default { randomBytes, randomUUID, createHash, scryptSync, timingSafeEqual, generateKeyPairSync, createHmac, createCipheriv, createDecipheriv, createSign };

package/polyfills/node_fs/index.js

@@ -1,8 +1,202 @@
-// Minimal fs shim: synchronous operations not supported in browser. Provide stubs.
-export function existsSync(){ return false; }
-export function readFileSync(){ throw new Error('node:fs.readFileSync is not supported in browser'); }
-export function writeFileSync(){ throw new Error('node:fs.writeFileSync is not supported in browser'); }
-export function readdirSync(){ return []; }
-export function mkdirSync(){ throw new Error('node:fs.mkdirSync not supported in browser'); }
-export function statSync(){ throw new Error('node:fs.statSync not supported in browser'); }
-export default { existsSync, readFileSync, writeFileSync };
+// ── In-memory cache backed by IndexedDB (async writes, sync reads from cache) ──
+
+const DB_NAME = 'vfs-fs-shim';
+const STORE   = 'files';
+let db = null;
+
+function openDB() {
+  if (db) return Promise.resolve(db);
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1);
+    req.onupgradeneeded = e => e.target.result.createObjectStore(STORE);
+    req.onsuccess  = e => { db = e.target.result; resolve(db); };
+    req.onerror    = e => reject(e.target.error);
+  });
+}
+
+// Sync cache (path → Uint8Array | null)
+const memCache = new Map();
+
+// Preload all keys into memCache at startup
+openDB().then(db => {
+  const tx = db.transaction(STORE, 'readonly');
+  const req = tx.objectStore(STORE).openCursor();
+  req.onsuccess = e => {
+    const cursor = e.target.result;
+    if (!cursor) return;
+    memCache.set(cursor.key, cursor.value);
+    cursor.continue();
+  };
+});
+
+function idbSet(path, value) {
+  openDB().then(db => {
+    const tx = db.transaction(STORE, 'readwrite');
+    if (value === null) tx.objectStore(STORE).delete(path);
+    else tx.objectStore(STORE).put(value, path);
+  });
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function toBytes(data, encoding = 'utf8') {
+  if (data instanceof Uint8Array) return data;
+  if (typeof data === 'string') {
+    if (encoding === 'hex') {
+      const arr = new Uint8Array(data.length / 2);
+      for (let i = 0; i < arr.length; i++)
+        arr[i] = parseInt(data.slice(i*2, i*2+2), 16);
+      return arr;
+    }
+    return new TextEncoder().encode(data);
+  }
+  return new Uint8Array(data);
+}
+
+function fromBytes(bytes, encoding = 'utf8') {
+  if (!encoding || encoding === 'utf8') return new TextDecoder().decode(bytes);
+  if (encoding === 'hex') return Array.from(bytes).map(b => b.toString(16).padStart(2,'0')).join('');
+  if (encoding === 'base64') return btoa(String.fromCharCode(...bytes));
+  return new TextDecoder().decode(bytes);
+}
+
+function parentPath(p) {
+  const parts = p.split('/').filter(Boolean);
+  parts.pop();
+  return '/' + parts.join('/');
+}
+
+// ── Sync API (reads from memCache) ───────────────────────────────────────────
+
+export function existsSync(path) {
+  return memCache.has(path);
+}
+
+export function readFileSync(path, optionsOrEncoding) {
+  if (!memCache.has(path)) throw Object.assign(new Error(`ENOENT: no such file: ${path}`), { code: 'ENOENT' });
+  const bytes = memCache.get(path);
+  if (bytes === '__DIR__') throw Object.assign(new Error(`EISDIR: ${path}`), { code: 'EISDIR' });
+  const enc = typeof optionsOrEncoding === 'string' ? optionsOrEncoding : optionsOrEncoding?.encoding;
+  if (enc) return fromBytes(bytes, enc);
+  return globalThis.Buffer.from(bytes); 
+}
+
+export function writeFileSync(path, data, optionsOrEncoding) {
+  const enc = typeof optionsOrEncoding === 'string' ? optionsOrEncoding : optionsOrEncoding?.encoding;
+  const bytes = toBytes(data, enc);
+  memCache.set(path, bytes);
+  idbSet(path, bytes);
+}
+
+export function appendFileSync(path, data, optionsOrEncoding) {
+  const enc = typeof optionsOrEncoding === 'string' ? optionsOrEncoding : optionsOrEncoding?.encoding;
+  const newBytes = toBytes(data, enc);
+  const existing = memCache.has(path) ? memCache.get(path) : new Uint8Array(0);
+  const merged = new Uint8Array(existing.length + newBytes.length);
+  merged.set(existing);
+  merged.set(newBytes, existing.length);
+  memCache.set(path, merged);
+  idbSet(path, merged);
+}
+
+export function unlinkSync(path) {
+  memCache.delete(path);
+  idbSet(path, null);
+}
+
+export function rmSync(path, options = {}) {
+  if (options.recursive) {
+    for (const key of [...memCache.keys()]) {
+      if (key === path || key.startsWith(path + '/')) {
+        memCache.delete(key);
+        idbSet(key, null);
+      }
+    }
+  } else {
+    unlinkSync(path);
+  }
+}
+
+export function mkdirSync(path, options = {}) {
+  if (options.recursive) {
+    // ensure all parents exist
+    const parts = path.split('/').filter(Boolean);
+    let cur = '';
+    for (const p of parts) {
+      cur += '/' + p;
+      if (!memCache.has(cur)) { memCache.set(cur, '__DIR__'); idbSet(cur, '__DIR__'); }
+    }
+  } else {
+    memCache.set(path, '__DIR__');
+    idbSet(path, '__DIR__');
+  }
+}
+
+export function readdirSync(path) {
+  const prefix = path.endsWith('/') ? path : path + '/';
+  return [...memCache.keys()]
+    .filter(k => k.startsWith(prefix) && k.slice(prefix.length).split('/').length === 1)
+    .map(k => k.slice(prefix.length));
+}
+
+export function statSync(path) {
+  if (!memCache.has(path)) throw Object.assign(new Error(`ENOENT: ${path}`), { code: 'ENOENT' });
+  const val = memCache.get(path);
+  const isDir = val === '__DIR__';
+  return {
+    isDirectory: () => isDir,
+    isFile: () => !isDir,
+    size: isDir ? 0 : val.length,
+  };
+}
+
+// ── fd stubs (journal uses these) ────────────────────────────────────────────
+
+const fdMap = new Map();
+let fdCounter = 10;
+
+export const constants = { O_WRONLY: 1, O_CREAT: 64, O_APPEND: 1024 };
+
+export function openSync(path, flags) {
+  const fd = fdCounter++;
+  const append = (flags & constants.O_APPEND) !== 0;
+  const existing = memCache.has(path) ? memCache.get(path) : new Uint8Array(0);
+  fdMap.set(fd, { path, data: append ? existing : new Uint8Array(0) });
+  return fd;
+}
+
+export function writeSync(fd, buf) {
+  const entry = fdMap.get(fd);
+  if (!entry) return;
+  const merged = new Uint8Array(entry.data.length + buf.length);
+  merged.set(entry.data);
+  merged.set(buf, entry.data.length);
+  entry.data = merged;
+}
+
+export function closeSync(fd) {
+  const entry = fdMap.get(fd);
+  if (!entry) return;
+  memCache.set(entry.path, entry.data);
+  idbSet(entry.path, entry.data);
+  fdMap.delete(fd);
+}
+
+export const ready = openDB().then(db => new Promise(resolve => {
+  const tx = db.transaction(STORE, 'readonly');
+  const req = tx.objectStore(STORE).openCursor();
+  req.onsuccess = e => {
+    const cursor = e.target.result;
+    if (!cursor) return resolve(true);
+    memCache.set(cursor.key, cursor.value);
+    cursor.continue();
+  };
+}));
+
+globalThis.__fsReady__ = ready; 
+
+export default {
+  existsSync, readFileSync, writeFileSync, appendFileSync,
+  unlinkSync, rmSync, mkdirSync, readdirSync, statSync,
+  openSync, writeSync, closeSync, constants, ready
+};

package/polyfills/node_path/index.js

@@ -1,14 +1,28 @@
 export const posix = {
-  basename(p){ const parts=p.split('/').filter(Boolean); return parts.length?parts[parts.length-1]:''; },
-  dirname(p){ if(!p) return '.'; const parts=p.split('/').filter(Boolean); parts.pop(); return parts.length?'/'+parts.join('/'):'/'; },
-  join(...parts){ return parts.join('/').replace(/\/+/g,'/'); },
-  resolve(...parts){ // naive resolve
+  basename(p) { const parts = p.split('/').filter(Boolean); return parts.length ? parts[parts.length - 1] : ''; },
+  dirname(p) { if (!p) return '.'; const parts = p.split('/').filter(Boolean); parts.pop(); return parts.length ? '/' + parts.join('/') : '/'; },
+  join(...parts) { return parts.join('/').replace(/\/+/g, '/'); },
+  resolve(...parts) { // naive resolve
     const joined = parts.join('/');
     if (joined.startsWith('/')) return joined;
-    return '/'+joined;
+    return '/' + joined;
   },
+  normalize(p) {
+    const parts = p.split('/');
+    const stack = [];
+    for (const part of parts) {
+      if (part === '..') stack.pop();
+      else if (part && part !== '.') stack.push(part);
+    }
+    return (p.startsWith('/') ? '/' : '') + stack.join('/') || '.';
+  }
 };
-export function basename(p){ return posix.basename(p); }
-export function dirname(p){ return posix.dirname(p); }
-export function resolve(...parts){ return posix.resolve(...parts); }
-export default { posix, basename, dirname, resolve };
+export function basename(p) { return posix.basename(p); }
+export function dirname(p) { return posix.dirname(p); }
+export function resolve(...parts) { return posix.resolve(...parts); }
+export function join(...parts) {
+  return parts.join('/').replace(/\/+/g, '/');
+}
+export function normalize(p) {
+  return posix.normalize(p);
+}

package/polyfills/process.js

@@ -0,0 +1,14 @@
+globalThis.startedat = Date.now();
+export const process = {
+  env: { NODE_ENV: 'production' },
+  version: 'v20.0.0',
+  platform: 'browser',
+  browser: true,
+  argv: [],
+  cwd: () => '/',
+  exit: () => {},
+  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),
+  memoryUsage: () => ({ rss: 0, heapTotal: 0, heapUsed: 0, external: 0 }),
+  uptime: () => (Date.now() - globalThis.startedat) / 1000,
+};
+globalThis.process = process;

package/polyfills/ssh2/index.js

@@ -0,0 +1,75 @@
+// ssh2 polyfill — browser stub. All methods throw NotImplemented.
+
+function notImpl(name) {
+  return function() {
+    throw new Error(`ssh2: ${name} not implemented in browser`);
+  };
+}
+
+// ── Client ────────────────────────────────────────────────────────────────────
+
+export class Client {
+  connect()              { notImpl('Client.connect')(); }
+  end()                  { notImpl('Client.end')(); }
+  destroy()              { notImpl('Client.destroy')(); }
+  exec()                 { notImpl('Client.exec')(); }
+  shell()                { notImpl('Client.shell')(); }
+  subsys()               { notImpl('Client.subsys')(); }
+  sftp()                 { notImpl('Client.sftp')(); }
+  forwardIn()            { notImpl('Client.forwardIn')(); }
+  unforwardIn()          { notImpl('Client.unforwardIn')(); }
+  forwardOut()           { notImpl('Client.forwardOut')(); }
+  openssh_noMoreSessions(){ notImpl('Client.openssh_noMoreSessions')(); }
+  openssh_forwardInStreamLocal() { notImpl('Client.openssh_forwardInStreamLocal')(); }
+  openssh_unforwardInStreamLocal(){ notImpl('Client.openssh_unforwardInStreamLocal')(); }
+  openssh_forwardOutStreamLocal() { notImpl('Client.openssh_forwardOutStreamLocal')(); }
+  on()                   { return this; }
+  once()                 { return this; }
+  off()                  { return this; }
+  emit()                 { return false; }
+  removeListener()       { return this; }
+}
+
+// ── Server ────────────────────────────────────────────────────────────────────
+
+export class Server {
+  constructor()          { notImpl('Server constructor')(); }
+  listen()               { notImpl('Server.listen')(); }
+  close()                { notImpl('Server.close')(); }
+  on()                   { return this; }
+  once()                 { return this; }
+  off()                  { return this; }
+  emit()                 { return false; }
+  removeListener()       { return this; }
+}
+
+// ── utils ─────────────────────────────────────────────────────────────────────
+
+export const utils = {
+  generateKeyPair:       notImpl('utils.generateKeyPair'),
+  generateKeyPairSync:   notImpl('utils.generateKeyPairSync'),
+  parseKey:              notImpl('utils.parseKey'),
+  parsePrivateKey:       notImpl('utils.parsePrivateKey'),
+  parsePublicKey:        notImpl('utils.parsePublicKey'),
+  decryptKey:            notImpl('utils.decryptKey'),
+  sftp: {
+    OPEN_MODE:  {},
+    STATUS_CODE: {},
+    flagsToString: notImpl('utils.sftp.flagsToString'),
+    stringToFlags:  notImpl('utils.sftp.stringToFlags'),
+  },
+};
+
+// ── HTTPAgent stubs ───────────────────────────────────────────────────────────
+
+export class HTTPAgent {
+  constructor() { notImpl('HTTPAgent constructor')(); }
+}
+
+export class HTTPSAgent {
+  constructor() { notImpl('HTTPSAgent constructor')(); }
+}
+
+// ── default export (mirrors ssh2 CommonJS shape) ─────────────────────────────
+
+export default { Client, Server, utils, HTTPAgent, HTTPSAgent };