webtalk 1.0.0

package/config.js

@@ -0,0 +1,36 @@
+const path = require('path');
+
+function createConfig(options = {}) {
+  const sdkDir = options.sdkDir || __dirname;
+
+  return {
+    // Server configuration
+    port: options.port || parseInt(process.env.PORT, 10) || 8080,
+
+    // Path configuration
+    sdkDir,
+    modelsDir: options.modelsDir || process.env.MODELS_DIR || path.join(sdkDir, 'models'),
+    ttsModelsDir: options.ttsModelsDir || process.env.TTS_MODELS_DIR || path.join(sdkDir, 'models', 'tts'),
+    assetsDir: options.assetsDir || path.join(sdkDir, 'assets'),
+    ttsDir: options.ttsDir || path.join(sdkDir, 'tts'),
+
+    // Model configuration
+    defaultWhisperModel: options.defaultWhisperModel || process.env.WHISPER_MODEL || 'onnx-community/whisper-base',
+    whisperBaseUrl: options.whisperBaseUrl || process.env.WHISPER_BASE_URL || 'https://huggingface.co/',
+    ttsBaseUrl: options.ttsBaseUrl || process.env.TTS_BASE_URL || 'https://huggingface.co/KevinAHM/pocket-tts-onnx/resolve/main/onnx/',
+
+    // Worker configuration
+    workerFile: options.workerFile || process.env.WORKER_FILE || 'worker-BPxxCWVT.js',
+    workerBackup: options.workerBackup || process.env.WORKER_BACKUP || 'worker-BPxxCWVT-original.js',
+    ttsWorkerFile: options.ttsWorkerFile || process.env.TTS_WORKER_FILE || 'inference-worker.js',
+
+    // URL configuration
+    onnxWasmUrl: options.onnxWasmUrl || process.env.ONNX_WASM_URL || 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.20.1/dist/ort-wasm-simd-threaded.jsep.wasm',
+
+    // Mount configuration
+    mountPath: options.mountPath || process.env.MOUNT_PATH || '/webtalk',
+    apiBasePath: options.apiBasePath || process.env.API_BASE_PATH || '',
+  };
+}
+
+module.exports = { createConfig };

package/debug.js

@@ -0,0 +1,21 @@
+const fs = require('fs');
+
+function createDebugAPI(state) {
+  return {
+    getDebugInfo() {
+      let whisperFiles = 0;
+      let ttsFiles = 0;
+      try { whisperFiles = fs.readdirSync(state.config.modelsDir).filter(f => !f.startsWith('.')).length; } catch (e) {}
+      try { ttsFiles = fs.readdirSync(state.config.ttsModelsDir).filter(f => !f.startsWith('.')).length; } catch (e) {}
+      return {
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+        nodeVersion: process.version,
+        platform: process.platform,
+        models: { whisperFiles, ttsFiles }
+      };
+    }
+  };
+}
+
+module.exports = { createDebugAPI };

package/download-lock.js

@@ -0,0 +1,26 @@
+const locks = new Map();
+const promises = new Map();
+
+function createDownloadLock(key) {
+  if (locks.has(key)) return promises.get(key);
+  const promise = new Promise((resolve, reject) => {
+    locks.set(key, { resolve, reject });
+  });
+  promises.set(key, promise);
+  return promise;
+}
+
+function resolveDownloadLock(key, value) {
+  const lock = locks.get(key);
+  if (lock) { lock.resolve(value); locks.delete(key); promises.delete(key); }
+}
+
+function rejectDownloadLock(key, error) {
+  const lock = locks.get(key);
+  if (lock) { lock.reject(error); locks.delete(key); promises.delete(key); }
+}
+
+function getDownloadPromise(key) { return promises.get(key); }
+function isDownloading(key) { return promises.has(key); }
+
+module.exports = { createDownloadLock, resolveDownloadLock, rejectDownloadLock, getDownloadPromise, isDownloading };

package/hot-reload.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+const path = require('path');
+const { getInFlightCount, setDraining, recordDrain, recordReload } = require('./persistent-state');
+
+const DRAIN_TIMEOUT = 5000;
+const DRAIN_INTERVAL = 10;
+const MAX_DRAIN_INTERVAL = 100;
+const WATCH_DEBOUNCE = 300;
+
+async function drain(timeout = DRAIN_TIMEOUT) {
+  recordDrain();
+  setDraining(true);
+  const startTime = Date.now();
+  let interval = DRAIN_INTERVAL;
+
+  while (getInFlightCount() > 0) {
+    if (Date.now() - startTime > timeout) {
+      setDraining(false);
+      throw new Error(`Drain timeout: ${getInFlightCount()} requests still in flight`);
+    }
+    await new Promise(r => setTimeout(r, interval));
+    interval = Math.min(interval * 2, MAX_DRAIN_INTERVAL);
+  }
+
+  setDraining(false);
+}
+
+function clearRequireCache(modules) {
+  modules.forEach(moduleName => {
+    const modulePath = path.resolve(moduleName.endsWith('.js') ? moduleName : moduleName + '.js');
+    delete require.cache[modulePath];
+    try { delete require.cache[require.resolve(modulePath)]; } catch (e) {}
+  });
+}
+
+function startFileWatcher(watchedFiles, reloadCallback) {
+  const watchers = [];
+  let reloadTimer = null;
+  let pending = false;
+
+  const onFileChange = () => {
+    if (reloadTimer) clearTimeout(reloadTimer);
+    pending = true;
+
+    reloadTimer = setTimeout(async () => {
+      if (pending) {
+        pending = false;
+        try {
+          await reloadCallback();
+        } catch (error) {
+          recordReload(error);
+        }
+      }
+    }, WATCH_DEBOUNCE);
+  };
+
+  try {
+    watchedFiles.forEach(filePath => {
+      const resolved = path.resolve(filePath);
+      const dir = path.dirname(resolved);
+      const basename = path.basename(resolved);
+      const watcher = fs.watch(dir, { persistent: false }, (eventType, filename) => {
+        if (filename === basename) onFileChange();
+      });
+      watchers.push(watcher);
+    });
+  } catch (error) {
+    recordReload(error);
+  }
+
+  return () => {
+    watchers.forEach(w => { try { w.close(); } catch (e) {} });
+    watchers.length = 0;
+    if (reloadTimer) clearTimeout(reloadTimer);
+  };
+}
+
+module.exports = { drain, clearRequireCache, startFileWatcher };

package/middleware.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+const { initState } = require('./persistent-state');
+const { ensureModel, downloadFile } = require('./whisper-models');
+const { ensureTTSModels, checkTTSModelExists } = require('./tts-models');
+const { patchWorker } = require('./worker-patch');
+const { serveStatic } = require('./serve-static');
+
+function webtalk(app, options = {}) {
+  const state = initState({ sdkDir: options.sdkDir || __dirname, ...options });
+  const config = state.config;
+  const mountPath = options.path || config.mountPath;
+
+  app.use((req, res, next) => {
+    res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
+    res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+    res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+    next();
+  });
+
+  app.get('/api/tts-status', async (req, res) => {
+    try {
+      const exists = await checkTTSModelExists(config);
+      res.json({ available: exists, modelDir: config.ttsModelsDir });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get(mountPath + '/sdk.js', (req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    res.sendFile(path.join(config.sdkDir, 'sdk.js'));
+  });
+
+  app.use('/assets', serveStatic(config.assetsDir));
+  app.use('/tts', serveStatic(config.ttsDir));
+  app.use('/models', serveStatic(config.modelsDir));
+
+  app.get(mountPath + '/demo', (req, res) => {
+    res.setHeader('Content-Type', 'text/html');
+    res.sendFile(path.join(config.sdkDir, 'app.html'));
+  });
+
+  app.use(mountPath, serveStatic(config.sdkDir, {
+    dotfiles: 'ignore', index: false,
+    extensions: ['html', 'js', 'css', 'png', 'svg', 'ico']
+  }));
+
+  const init = async () => {
+    try { patchWorker(config); } catch (e) {}
+    const ortWasmFile = path.join(config.assetsDir, 'ort-wasm-simd-threaded.jsep.wasm');
+    if (!fs.existsSync(ortWasmFile)) {
+      await downloadFile(config.onnxWasmUrl, ortWasmFile);
+    }
+    await ensureModel(config.defaultWhisperModel, config);
+    await ensureTTSModels(config);
+  };
+
+  return { init };
+}
+
+module.exports = { webtalk };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "webtalk",
+  "version": "1.0.0",
+  "description": "Buildless STT (Whisper WebGPU) + TTS (Pocket TTS ONNX) SDK",
+  "main": "middleware.js",
+  "type": "commonjs",
+  "exports": {
+    ".": "./middleware.js",
+    "./middleware": "./middleware.js",
+    "./sdk": "./sdk.js",
+    "./stt": "./stt.js",
+    "./tts": "./tts.js",
+    "./config": "./config.js",
+    "./server": "./server.js"
+  },
+  "scripts": {
+    "start": "node server.js"
+  },
+  "keywords": ["whisper", "webgpu", "stt", "tts", "speech", "audio"],
+  "author": "anEntrypoint",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AnEntrypoint/realtime-whisper-webgpu.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AnEntrypoint/realtime-whisper-webgpu/issues"
+  },
+  "homepage": "https://github.com/AnEntrypoint/realtime-whisper-webgpu",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/persistent-state.js

@@ -0,0 +1,62 @@
+const { createConfig } = require('./config');
+
+const state = {
+  config: null,
+  handlers: { current: null },
+  requests: { inFlight: 0, draining: false },
+  reload: { count: 0, lastTime: 0, lastError: null },
+  debug: { reloadEvents: [], drainEvents: [] }
+};
+
+function initState(options = {}) {
+  if (!state.config) {
+    state.config = createConfig(options);
+  }
+  return state;
+}
+
+function trackRequest() { state.requests.inFlight++; }
+function untrackRequest() { state.requests.inFlight--; }
+function getInFlightCount() { return state.requests.inFlight; }
+
+function setCurrentHandlers(handlers) { state.handlers.current = handlers; }
+function getCurrentHandlers() { return state.handlers.current; }
+
+function setDraining(draining) { state.requests.draining = draining; }
+
+function recordReload(error = null) {
+  state.reload.count++;
+  state.reload.lastTime = Date.now();
+  if (error) state.reload.lastError = error.message;
+  state.debug.reloadEvents.push({
+    count: state.reload.count,
+    time: state.reload.lastTime,
+    error: error ? error.message : null
+  });
+  if (state.debug.reloadEvents.length > 100) state.debug.reloadEvents.shift();
+}
+
+function recordDrain() {
+  state.debug.drainEvents.push({ time: Date.now(), inFlight: state.requests.inFlight });
+  if (state.debug.drainEvents.length > 100) state.debug.drainEvents.shift();
+}
+
+function getDebugState() {
+  return {
+    reloadCount: state.reload.count,
+    inFlightRequests: state.requests.inFlight,
+    isDraining: state.requests.draining,
+    lastReloadTime: state.reload.lastTime,
+    lastReloadError: state.reload.lastError,
+    recentEvents: {
+      reloads: state.debug.reloadEvents.slice(-5),
+      drains: state.debug.drainEvents.slice(-5)
+    }
+  };
+}
+
+module.exports = {
+  initState, trackRequest, untrackRequest, getInFlightCount,
+  setCurrentHandlers, getCurrentHandlers,
+  setDraining, recordReload, recordDrain, getDebugState
+};

package/sdk.js

@@ -0,0 +1,22 @@
+import { STT } from './stt.js';
+import { TTS } from './tts.js';
+
+const debug = {
+  getSDKVersion() {
+    return '1.0.0';
+  },
+  getLoadedModules() {
+    return {
+      stt: typeof STT !== 'undefined',
+      tts: typeof TTS !== 'undefined'
+    };
+  },
+  getPageInfo() {
+    return {
+      url: typeof window !== 'undefined' ? window.location.href : 'N/A',
+      userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'N/A'
+    };
+  }
+};
+
+export { STT, TTS, debug };

package/serve-static.js

@@ -0,0 +1,45 @@
+const fs = require('fs');
+const path = require('path');
+
+const MIME_TYPES = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.otf': 'font/otf',
+  '.onnx': 'application/octet-stream',
+  '.wasm': 'application/wasm',
+  '.bin': 'application/octet-stream',
+  '.model': 'application/octet-stream'
+};
+
+function serveStatic(root, options = {}) {
+  return (req, res, next) => {
+    const urlPath = decodeURIComponent(req.path || req.url);
+    const filePath = path.join(root, urlPath);
+
+    if (!filePath.startsWith(root)) {
+      return res.status(403).end('Forbidden');
+    }
+
+    fs.stat(filePath, (err, stats) => {
+      if (err || !stats.isFile()) return next();
+      const ext = path.extname(filePath).toLowerCase();
+      const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+      res.setHeader('Content-Type', contentType);
+      fs.createReadStream(filePath).pipe(res);
+    });
+  };
+}
+
+module.exports = { serveStatic };

package/server.js

@@ -0,0 +1,177 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const url = require('url');
+const { webtalk } = require('./middleware');
+const { initState, trackRequest, untrackRequest, getCurrentHandlers, setCurrentHandlers, getDebugState } = require('./persistent-state');
+const { startFileWatcher, drain, clearRequireCache } = require('./hot-reload');
+const { createDebugAPI } = require('./debug');
+
+const MIME_TYPES = {
+  '.html': 'text/html', '.js': 'application/javascript',
+  '.css': 'text/css', '.json': 'application/json', '.png': 'image/png'
+};
+
+const state = initState();
+const config = state.config;
+const debugAPI = createDebugAPI(state);
+let stopWatcher = null;
+
+process.webtalk = debugAPI;
+
+function createApp() {
+  function app(req, res) {
+    trackRequest();
+    const onEnd = () => {
+      untrackRequest();
+      res.removeListener('finish', onEnd);
+      res.removeListener('close', onEnd);
+    };
+    res.on('finish', onEnd);
+    res.on('close', onEnd);
+
+    res.json = (data) => {
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify(data));
+    };
+    res.status = (code) => { res.statusCode = code; return res; };
+    res.sendFile = (filePath) => {
+      const ext = path.extname(filePath).toLowerCase();
+      res.setHeader('Content-Type', MIME_TYPES[ext] || 'application/octet-stream');
+      fs.createReadStream(filePath).pipe(res);
+    };
+
+    const parsed = url.parse(req.url);
+    req.path = parsed.pathname;
+
+    const handlers = getCurrentHandlers();
+    if (!handlers) {
+      res.statusCode = 503;
+      res.end('Server initializing');
+      return;
+    }
+
+    let idx = 0;
+    const allHandlers = [];
+
+    for (const item of handlers.USE) {
+      allHandlers.push({ prefix: item.prefix, handler: item.handler });
+    }
+
+    if (req.method === 'GET') {
+      for (const [routePath, handler] of Object.entries(handlers.GET)) {
+        allHandlers.push({ exactPath: routePath, handler });
+      }
+    }
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    function next() {
+      if (idx >= allHandlers.length) {
+        if (req.path === '/' || req.path === '') {
+          res.sendFile(path.join(__dirname, 'app.html'));
+          return;
+        }
+        res.statusCode = 404;
+        res.end('Not Found');
+        return;
+      }
+      const h = allHandlers[idx++];
+      if (h.exactPath) {
+        if (req.path === h.exactPath) {
+          h.handler(req, res, next);
+        } else {
+          next();
+        }
+      } else if (h.prefix) {
+        if (req.path.startsWith(h.prefix)) {
+          const originalPath = req.path;
+          req.path = req.path.slice(h.prefix.length) || '/';
+          req.url = req.path;
+          h.handler(req, res, () => {
+            req.path = originalPath;
+            req.url = originalPath;
+            next();
+          });
+        } else {
+          next();
+        }
+      } else {
+        h.handler(req, res, next);
+      }
+    }
+
+    next();
+  }
+
+  app.get = (p, handler) => {
+    const handlers = getCurrentHandlers() || { GET: {}, USE: [] };
+    handlers.GET[p] = handler;
+    setCurrentHandlers(handlers);
+  };
+
+  app.use = (prefixOrHandler, handler) => {
+    const handlers = getCurrentHandlers() || { GET: {}, USE: [] };
+    if (typeof prefixOrHandler === 'function') {
+      handlers.USE.push({ prefix: null, handler: prefixOrHandler });
+    } else {
+      handlers.USE.push({ prefix: prefixOrHandler, handler });
+    }
+    setCurrentHandlers(handlers);
+  };
+
+  return app;
+}
+
+const app = createApp();
+const { init } = webtalk(app);
+const server = http.createServer(app);
+
+server.on('error', (err) => {
+  process.stderr.write(err.message + '\n');
+  process.exit(1);
+});
+
+async function reloadMiddleware() {
+  await drain();
+  clearRequireCache(['./middleware.js', './config.js']);
+  delete require.cache[require.resolve('./middleware.js')];
+  delete require.cache[require.resolve('./config.js')];
+  const { webtalk: reloadedWebtalk } = require('./middleware.js');
+  const newApp = createApp();
+  const { init: newInit } = reloadedWebtalk(newApp);
+  await newInit();
+  newApp.get('/api/debug', (req, res) => {
+    res.json(getDebugState());
+  });
+}
+
+function shutdown() {
+  if (stopWatcher) stopWatcher();
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(0), 2000).unref();
+}
+
+async function startServer() {
+  await init();
+  app.get('/api/debug', (req, res) => {
+    res.json({ ...getDebugState(), api: debugAPI.getDebugInfo() });
+  });
+  server.listen(config.port, '0.0.0.0');
+  stopWatcher = startFileWatcher(
+    ['./middleware.js', './config.js'],
+    reloadMiddleware
+  );
+}
+
+startServer().catch((err) => {
+  process.stderr.write((err.message || 'Startup failed') + '\n');
+  process.exit(1);
+});
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);