Enhance lively.context to leverage nw.js + node:inspect

install.sh

@@ -117,6 +117,19 @@ then
   exit
 fi
 
+section "Installing Puppeteer browser"
+step "Preparing Chrome for headless tests..."
+node "$(node -p "require.resolve('puppeteer/install.mjs')")" || exit 1
+node <<'NODE' || exit 1
+const fs = require('fs');
+const puppeteer = require('puppeteer');
+const executable = puppeteer.executablePath();
+if (!fs.existsSync(executable)) {
+  throw new Error(`Puppeteer browser executable does not exist: ${executable}`);
+}
+console.log(`   Puppeteer Chrome ready at ${executable}`);
+NODE
+
 section "Building SWC plugin"
 if ! rustup target list --installed | grep -q "^wasm32-wasip1$"; then
   step "Adding Rust target wasm32-wasip1..."

lively.app/desktop/inject.js

@@ -47,11 +47,63 @@
     return window.confirm([title, message].filter(Boolean).join('\n\n'));
   }
 
+  const desktop = window.livelyDesktop || {};
+  const desktopDebugger = desktop.debugger || {};
+  const debuggerState = window.__LIVELY_DESKTOP_DEBUGGER__ || (window.__LIVELY_DESKTOP_DEBUGGER__ = {
+    armedHalt: null,
+    captures: [],
+    serviceAttached: !!desktopDebugger.inspectorServiceAttached
+  });
+  if (desktopDebugger.inspectorServiceAttached) debuggerState.serviceAttached = true;
+
+  function armHalt (capture) {
+    if (!debuggerState.serviceAttached) return false;
+    debuggerState.armedHalt = {
+      captureId: capture && capture.captureId,
+      reason: capture && capture.reason || 'halt',
+      armedAt: Date.now()
+    };
+    return true;
+  }
+
+  function consumeArmedHalt () {
+    const capture = debuggerState.armedHalt;
+    debuggerState.armedHalt = null;
+    return capture;
+  }
+
+  function isAvailable () {
+    return !!debuggerState.serviceAttached;
+  }
+
+  function setServiceAttached (attached) {
+    debuggerState.serviceAttached = !!attached;
+    return debuggerState.serviceAttached;
+  }
+
+  function deliverCapture (descriptor) {
+    debuggerState.captures.push(descriptor);
+    debuggerState.lastCapture = descriptor;
+    try {
+      window.dispatchEvent(new CustomEvent('lively-desktop-debugger-capture', { detail: descriptor }));
+    } catch (_) {}
+    return true;
+  }
+
   window.livelyDesktop = {
+    ...desktop,
     navigateToDashboard: navigateToDashboard,
     showDevTools: showDevTools,
     showDesktopMessage: showDesktopMessage,
-    confirmDesktopAction: confirmDesktopAction
+    confirmDesktopAction: confirmDesktopAction,
+    debugger: {
+      ...desktopDebugger,
+      armHalt: desktopDebugger.armHalt || armHalt,
+      consumeArmedHalt: desktopDebugger.consumeArmedHalt || consumeArmedHalt,
+      isAvailable: desktopDebugger.isAvailable || isAvailable,
+      setServiceAttached: desktopDebugger.setServiceAttached || setServiceAttached,
+      deliverCapture: desktopDebugger.deliverCapture || deliverCapture
+    }
   };
 
   // Keyboard shortcut: Cmd/Ctrl + Shift + D → Dashboard.

lively.app/desktop/inspector-service-runner.cjs

@@ -0,0 +1,40 @@
+// Runs the CDP-backed inspector service outside NW.js's renderer isolate.
+//
+// The renderer pauses briefly when lively.context throws its halt unwind
+// exception. This plain Node process handles the CDP event, captures the
+// paused stack, then resumes the renderer so normal exception unwinding can
+// return control to the Lively UI.
+
+const { createInspectorService } = require('./inspector-service.cjs');
+
+function parseArgs () {
+  const args = {};
+  for (const arg of process.argv.slice(2)) {
+    const match = arg.match(/^--([^=]+)=(.*)$/);
+    if (match) args[match[1]] = match[2];
+  }
+  return args;
+}
+
+const args = parseArgs();
+const cdpPort = Number(args.cdpPort || process.env.LIVELY_APP_CDP_PORT || 9222);
+const service = createInspectorService({
+  cdpPort: Number.isFinite(cdpPort) && cdpPort > 0 ? cdpPort : 9222,
+  log: msg => console.log(msg)
+});
+
+function stop () {
+  try { service.stop(); } catch (_) {}
+  process.exit(0);
+}
+
+process.on('SIGTERM', stop);
+process.on('SIGINT', stop);
+
+service.start().then(() => {
+  // Keep the helper alive; the parent-death watchdog is preloaded by node-main.
+  setInterval(() => {}, 1 << 30);
+}).catch(err => {
+  console.error(err && (err.stack || err.message) || String(err));
+  process.exit(1);
+});