@wrongstack/webui 0.104.0 → 0.107.2

package/dist/server/index.d.ts

@@ -106,7 +106,8 @@ declare function browserOpenCommand(url: string, platform?: NodeJS.Platform): {
     command: string;
     args: string[];
 };
-/** Spawn the OS browser-opener for `url`. Never throws. */
+/** Spawn the OS browser-opener for `url` and register it as a protected
+ *  process so it survives kill/killAll. Never throws. */
 declare function openBrowser(url: string, platform?: NodeJS.Platform): void;
 
 /**

package/dist/server/index.js

@@ -1614,6 +1614,25 @@ function openBrowser(url, platform = process.platform) {
     child.on("error", () => {
     });
     child.unref();
+    if (child.pid) {
+      try {
+        import("@wrongstack/tools").then(({ getProcessRegistry }) => {
+          getProcessRegistry().register({
+            pid: child.pid,
+            name: "browser",
+            command: `${command} ${args.join(" ")}`,
+            startedAt: Date.now(),
+            child,
+            protected: true
+          });
+          child.on("exit", () => {
+            getProcessRegistry().unregister(child.pid);
+          });
+        }).catch(() => {
+        });
+      } catch {
+      }
+    }
   } catch {
   }
 }
@@ -3151,6 +3170,111 @@ async function startWebUI(opts = {}) {
         });
         break;
       }
+      case "process.list": {
+        try {
+          const { getProcessRegistry } = await import("@wrongstack/tools");
+          const procs = getProcessRegistry().list();
+          send(ws, {
+            type: "process.list",
+            payload: {
+              processes: procs.map((p) => ({
+                pid: p.pid,
+                command: p.command,
+                tool: p.name,
+                startedAt: p.startedAt,
+                status: p.killed ? "killed" : "running",
+                protected: p.protected
+              }))
+            }
+          });
+        } catch {
+          send(ws, { type: "process.list", payload: { processes: [] } });
+        }
+        break;
+      }
+      case "process.kill": {
+        const { pid } = msg.payload;
+        try {
+          const { getProcessRegistry } = await import("@wrongstack/tools");
+          const proc = getProcessRegistry().get(pid);
+          if (proc?.protected) {
+            sendResult(ws, false, `Cannot kill protected process (PID ${pid})`);
+            break;
+          }
+          getProcessRegistry().kill(pid);
+          sendResult(ws, true, `Killed PID ${pid}`);
+        } catch (err) {
+          sendResult(ws, false, errMessage(err));
+        }
+        break;
+      }
+      case "process.killAll": {
+        try {
+          const { getProcessRegistry } = await import("@wrongstack/tools");
+          getProcessRegistry().killAll();
+          sendResult(ws, true, "All processes killed");
+        } catch (err) {
+          sendResult(ws, false, errMessage(err));
+        }
+        break;
+      }
+      case "goal.get": {
+        try {
+          const goalPath = path4.join(projectRoot, ".wrongstack", "goal.json");
+          const raw = await fs4.readFile(goalPath, "utf8");
+          const goal = JSON.parse(raw);
+          broadcast(clients, { type: "goal.updated", payload: goal });
+        } catch {
+          broadcast(clients, { type: "goal.updated", payload: null });
+        }
+        break;
+      }
+      case "autonomy.switch": {
+        const { mode } = msg.payload;
+        context.meta["autonomy"] = mode;
+        sendResult(ws, true, `Autonomy mode set to "${mode}"`);
+        break;
+      }
+      case "session.checkpoints": {
+        try {
+          const { DefaultSessionRewinder } = await import("@wrongstack/core");
+          const rewinder = new DefaultSessionRewinder(
+            path4.join(projectRoot, ".wrongstack", "sessions"),
+            projectRoot
+          );
+          const checkpoints = await rewinder.listCheckpoints(session.id);
+          send(ws, {
+            type: "session.checkpoints",
+            payload: { checkpoints }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "session.checkpoints",
+            payload: { checkpoints: [] }
+          });
+        }
+        break;
+      }
+      case "session.rewind": {
+        const { checkpointIndex } = msg.payload;
+        try {
+          const { DefaultSessionRewinder } = await import("@wrongstack/core");
+          const rewinder = new DefaultSessionRewinder(
+            path4.join(projectRoot, ".wrongstack", "sessions"),
+            projectRoot
+          );
+          await rewinder.rewindToCheckpoint(session.id, checkpointIndex);
+          await context.session.truncateToCheckpoint(checkpointIndex);
+          sendResult(ws, true, `Rewound to checkpoint ${checkpointIndex}`);
+          broadcast(clients, {
+            type: "session.start",
+            payload: { ...await sessionStartPayload(), reset: true }
+          });
+        } catch (err) {
+          sendResult(ws, false, errMessage(err));
+        }
+        break;
+      }
       default:
         if (msg.type.startsWith("autophase.")) {
           await autoPhaseHandler.handleMessage(