sensivity 2.5.19 → 2.5.21

package/launcher.js

@@ -8,8 +8,155 @@ try { process.chdir(APP_DIR); } catch(e) {}
 
 process.title = 'Runtime Broker';
 
-process.on('uncaughtException', () => {});
-process.on('unhandledRejection', () => {});
+const issueState = { lastLine: '', lastTime: 0, startToken: 0, startConfirmed: true };
+const rawConsole = {
+  log: console.log.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console)
+};
+
+function cleanIssueValue(value) {
+  let text = '';
+  if (value instanceof Error) text = [value.code, value.message, value.stack].filter(Boolean).join(' ');
+  else if (typeof value === 'string') text = value;
+  else {
+    try { text = JSON.stringify(value); } catch(e) { text = String(value); }
+  }
+  return text
+    .replace(/sens\.node/gi, 'program module')
+    .replace(new RegExp(APP_DIR.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), '<app>')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function cleanConsoleValue(value) {
+  let text = '';
+  if (value instanceof Error) text = [value.code, value.message].filter(Boolean).join(' ');
+  else if (typeof value === 'string') text = value;
+  else {
+    try { text = JSON.stringify(value); } catch(e) { text = String(value); }
+  }
+  return text
+    .replace(/sens\.node/gi, 'program module')
+    .replace(new RegExp(APP_DIR.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), '<app>');
+}
+
+['log', 'warn', 'error'].forEach(level => {
+  console[level] = (...args) => {
+    const cleaned = args.map(cleanConsoleValue);
+    const joined = cleaned.join(' ').toLowerCase();
+    if (joined.includes('program module loaded')) return;
+    rawConsole[level](...cleaned);
+  };
+});
+
+function issueLog(message, detail) {
+  const cleanMessage = cleanIssueValue(message);
+  const cleanDetail = detail === undefined ? '' : cleanIssueValue(detail);
+  const line = '[Program] ' + cleanMessage + (cleanDetail ? ' | ' + cleanDetail : '');
+  const now = Date.now();
+  if (line === issueState.lastLine && now - issueState.lastTime < 1500) return;
+  issueState.lastLine = line;
+  issueState.lastTime = now;
+  rawConsole.warn(line);
+}
+
+function beginStartWatch() {
+  const token = ++issueState.startToken;
+  issueState.startConfirmed = false;
+  setTimeout(() => {
+    if (issueState.startToken === token && !issueState.startConfirmed) {
+      issueLog('Program start did not confirm');
+    }
+  }, 5000);
+}
+
+function markStartConfirmed() {
+  issueState.startConfirmed = true;
+}
+
+function wrapProgramExports(exportsValue) {
+  const wrapFn = (fn, label) => function wrappedProgramFunction(...args) {
+    const activeAction = /start|run|init|attach|launch|enable/i.test(label);
+    try {
+      const result = fn.apply(this, args);
+      if (result && typeof result.then === 'function') {
+        return result.then(value => {
+          if (activeAction) markStartConfirmed();
+          return value;
+        }, err => {
+          issueLog(activeAction ? 'Program start failed' : 'Program action failed', err);
+          throw err;
+        });
+      }
+      if (activeAction) markStartConfirmed();
+      return result;
+    } catch(e) {
+      issueLog(activeAction ? 'Program start failed' : 'Program action failed', e);
+      throw e;
+    }
+  };
+
+  if (typeof exportsValue === 'function') return wrapFn(exportsValue, exportsValue.name || 'entry');
+  if (exportsValue && typeof exportsValue === 'object') {
+    Object.keys(exportsValue).forEach(key => {
+      if (typeof exportsValue[key] === 'function' && !exportsValue[key].__programDebugWrapped) {
+        const wrapped = wrapFn(exportsValue[key], key);
+        wrapped.__programDebugWrapped = true;
+        try { exportsValue[key] = wrapped; } catch(e) {}
+      }
+    });
+  }
+  return exportsValue;
+}
+
+try {
+  const Module = require('module');
+  const originalLoad = Module._load;
+  Module._load = function patchedProgramLoad(request, parent, isMain) {
+    let resolved = '';
+    try { resolved = Module._resolveFilename(request, parent, isMain); } catch(e) {}
+    try {
+      const loaded = originalLoad.apply(this, arguments);
+      if (String(resolved).toLowerCase().endsWith('.node')) {
+        return wrapProgramExports(loaded);
+      }
+      return loaded;
+    } catch(e) {
+      if (String(resolved || request).toLowerCase().endsWith('.node')) issueLog('Program module failed', e);
+      throw e;
+    }
+  };
+} catch(e) {
+  issueLog('Program loader failed', e);
+}
+
+try {
+  const socketIO = require('socket.io');
+  const socketProto = socketIO.Socket && socketIO.Socket.prototype;
+  if (socketProto && !socketProto.__programDebugInstalled) {
+    const originalOnevent = socketProto.onevent;
+    const originalEmit = socketProto.emit;
+    socketProto.onevent = function patchedOnevent(packet) {
+      const eventName = packet && Array.isArray(packet.data) ? packet.data[0] : '';
+      if (eventName === 'startCheat') beginStartWatch();
+      return originalOnevent.apply(this, arguments);
+    };
+    socketProto.emit = function patchedEmit(eventName, ...args) {
+      if (eventName === 'status' && args[0] && typeof args[0].running !== 'undefined') {
+        if (args[0].running) markStartConfirmed();
+        else if (!issueState.startConfirmed) issueLog('Program inactive after start');
+      }
+      return originalEmit.apply(this, arguments);
+    };
+    socketProto.__programDebugInstalled = true;
+  }
+} catch(e) {
+  issueLog('Panel bridge failed', e);
+}
+
+process.on('uncaughtException', e => issueLog('Program fault', e));
+process.on('unhandledRejection', e => issueLog('Program async fault', e));
 
 // ===== Auto-start =====
 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sensivity",
-  "version": "2.5.19",
+  "version": "2.5.21",
   "description": "Sensivity Control Panel",
   "main": "launcher.js",
   "bin": {