local-operator-ui 0.34.30 → 0.34.31

package/out/main/index.js

@@ -15725,10 +15725,10 @@ class ConsoleRegistry {
   count() {
     return this.entries.size;
   }
-  /** How many were created by that session's agent. */
+  /** How many live surfaces were created by that session's agent. */
   agentCount(sessionId2) {
     return this.list(sessionId2).filter(
-      (entry) => entry.record.origin === "agent"
+      (entry) => entry.record.origin === "agent" && entry.record.live
     ).length;
   }
   /**
@@ -15747,7 +15747,7 @@ class ConsoleRegistry {
         { limit: MAX_SURFACES_PER_APP, scope: "app" }
       );
     }
-    if (input.origin === "agent" && this.agentCount(input.sessionId) >= MAX_AGENT_SURFACES_PER_SESSION) {
+    if (input.live !== false && input.origin === "agent" && this.agentCount(input.sessionId) >= MAX_AGENT_SURFACES_PER_SESSION) {
       throw new ConsoleError(
         "tab_limit",
         `this session's agent is already running ${MAX_AGENT_SURFACES_PER_SESSION} console surfaces; close one first`,
@@ -15766,10 +15766,10 @@ class ConsoleRegistry {
       cwd: input.cwd,
       cols: input.cols,
       rows: input.rows,
-      running: true,
+      running: input.live !== false,
       exitCode: null,
       lastActivity: this.now(),
-      live: true,
+      live: input.live !== false,
       retain: input.retain,
       secure: false,
       lastActor: null,
@@ -15897,6 +15897,10 @@ const SURFACE_COLORTERM = "truecolor";
 const STRIPPED_ENV_PREFIXES = ["CMUX_", "LOP_"];
 class ConsoleHost {
   registry;
+  rollbackDisposals = [];
+  // Acquisition precedes runtime construction/registry adoption. Keep the exact
+  // emulator until adoption succeeds; startup rollback must also own that gap.
+  unboundRestoreEmulators = /* @__PURE__ */ new Set();
   options;
   now;
   env;
@@ -16058,6 +16062,7 @@ class ConsoleHost {
       // The handle the history recorded, so a caller holding one across a relaunch
       // finds the same surface rather than a lookalike with a new nonce.
       surface: meta.surface,
+      live: false,
       sessionId: meta.session_id,
       origin: meta.origin,
       command: meta.command,
@@ -16081,7 +16086,7 @@ class ConsoleHost {
       rows: grid.rows,
       scrollback: SCROLLBACK_LINES
     });
-    emulator.write(bytes);
+    this.unboundRestoreEmulators.add(emulator);
     const runtime = {
       // A reconstructed surface has no pty. `null` rather than a fake process:
       // every path that would signal one checks `running` first, and the record
@@ -16103,8 +16108,10 @@ class ConsoleHost {
       exitDelivered: true,
       exitWaiters: []
     };
-    runtime.log.append(bytes);
     this.registry.attach(entry.record.surface, runtime);
+    this.unboundRestoreEmulators.delete(emulator);
+    emulator.write(bytes);
+    runtime.log.append(bytes);
     this.registry.update(entry.record.surface, {
       running: false,
       exitCode: meta.exit_code,
@@ -16818,17 +16825,63 @@ class ConsoleHost {
     this.options.onChanged?.();
   }
   /** Stop everything: every pty, every record, every subscriber. */
-  dispose() {
-    for (const entry of this.registry.clear()) {
-      const runtime = entry.runtime;
-      if (!runtime) continue;
-      if (runtime.pendingTimer) clearTimeout(runtime.pendingTimer);
-      if (runtime.persistTimer) clearTimeout(runtime.persistTimer);
-      runtime.subscribers.clear();
-      if (entry.record.retain) this.persist(entry, runtime);
-      if (entry.record.running) runtime.pty?.kill();
-      runtime.emulator.dispose();
-    }
+  dispose(persistHistory = true) {
+    if (!persistHistory || this.rollbackDisposals.length > 0 || this.unboundRestoreEmulators.size > 0) {
+      const entries = [...this.rollbackDisposals, ...this.registry.clear()];
+      this.rollbackDisposals = [];
+      const failures = [];
+      for (const entry of entries) {
+        if (entry.runtime)
+          this.unboundRestoreEmulators.delete(entry.runtime.emulator);
+      }
+      for (const entry of entries) {
+        const runtime = entry.runtime;
+        if (!runtime) continue;
+        let incomplete = false;
+        for (const release of [
+          () => {
+            if (runtime.pendingTimer) clearTimeout(runtime.pendingTimer);
+            if (runtime.persistTimer) clearTimeout(runtime.persistTimer);
+            runtime.subscribers.clear();
+          },
+          () => {
+            if (entry.record.running) runtime.pty?.kill();
+          },
+          () => runtime.emulator.dispose()
+        ]) {
+          try {
+            release();
+          } catch (error) {
+            incomplete = true;
+            failures.push(error);
+          }
+        }
+        if (incomplete) this.rollbackDisposals.push(entry);
+      }
+      for (const emulator of this.unboundRestoreEmulators) {
+        try {
+          emulator.dispose();
+          this.unboundRestoreEmulators.delete(emulator);
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      if (failures.length)
+        throw new AggregateError(
+          failures,
+          "Partial console runtime cleanup incomplete."
+        );
+    } else
+      for (const entry of this.registry.clear()) {
+        const runtime = entry.runtime;
+        if (!runtime) continue;
+        if (runtime.pendingTimer) clearTimeout(runtime.pendingTimer);
+        if (runtime.persistTimer) clearTimeout(runtime.persistTimer);
+        runtime.subscribers.clear();
+        if (persistHistory && entry.record.retain) this.persist(entry, runtime);
+        if (entry.record.running) runtime.pty?.kill();
+        runtime.emulator.dispose();
+      }
     this.createdAt.clear();
     this.persistedBytes.clear();
     this.metaSignatures.clear();
@@ -17864,112 +17917,158 @@ async function startConsoleHost(options) {
       `[console] restored the exec bit on ${load.helper.path ?? "spawn-helper"}`
     );
   }
-  const configDir = options.configDir ?? localOperatorConfigDir();
-  const history = new ConsoleHistory(
-    path$1.join(configDir, "run", "ui-console", "history")
-  );
-  const registry = new ConsoleRegistry();
   let hostRef = null;
-  const completion = consoleCompletionHooks({
-    host: () => hostRef,
-    registry,
-    notifier: () => options.notifier ?? null,
-    log: log2,
-    now: options.now
-  });
-  const capture = options.consoleCaptureUrl && options.preloadPath ? new ConsoleCaptureView({
-    url: options.consoleCaptureUrl,
-    preload: options.preloadPath,
-    log: log2
-  }) : null;
-  const host = new ConsoleHost(registry, {
-    window: () => options.window,
-    log: log2,
-    history,
-    now: options.now,
-    // Resolved BEFORE the host exists, so no surface can be created against the
-    // launch environment and then start behaving like the user's terminal later:
-    // a surface's PATH is decided here, once, and every surface this host makes
-    // carries the same one. Bounded by the resolver's own timeout (it never
-    // rejects and answers null when the shell cannot speak), and no part of the
-    // app's own startup waits on it: the browser host is attached to the window
-    // without being awaited, so the cost of a slow rc here is this host coming
-    // online later, not the app failing to come up.
-    env: await withUserShellPath(process.env, options.userShellPath),
-    captureOffscreen: capture ? (request) => capture.capture(request) : void 0,
-    spawn: options.spawn ?? ((spawnOptions) => spawnPty(load.module, spawnOptions, (report) => {
-      log2(
-        `[console] restored the exec bit on ${report.path ?? "spawn-helper"}`
-      );
-    })),
-    /*
-     * ONE PUSHER, and it is A's. `broadcastConsoleState` was already the app's
-     * single "the projection moved" signal when this branch arrived; the
-     * completion seam below therefore does NOT push a second copy of the same
-     * frame. It only raises a banner, which is the half a push cannot express —
-     * and the host calls `onChanged` for a mark and an exit too, so the renderer
-     * still refetches on both (see `ConsoleHostOptions.onExit`).
-     */
-    onChanged: () => {
-      broadcastConsoleState(options.window);
-    },
-    onMark: completion.onMark,
-    onExit: completion.onExit,
-    onReveal: (request) => {
-      const window = options.window;
-      if (window.isDestroyed()) return;
-      window.webContents.send("console-reveal", {
-        surface: request.surface,
-        session_id: request.sessionId,
-        mode: request.mode
-      });
+  let capture = null;
+  let host = null;
+  let rollbackOwners = [];
+  const cleanupStartupOwners = () => {
+    const pending = [];
+    const failures = [];
+    for (const release of rollbackOwners.splice(0).reverse()) {
+      try {
+        release();
+      } catch (error) {
+        pending.unshift(release);
+        failures.push(error);
+      }
     }
-  });
-  if (options.restoreHistory !== false) {
-    const retained = history.list().sort((a, b) => b.meta.last_seen_at - a.meta.last_seen_at).slice(0, MAX_SURFACES_PER_APP);
-    for (const surface of retained) {
-      host.restore(surface.meta, surface.bytes);
+    rollbackOwners = pending;
+    if (failures.length)
+      throw new AggregateError(failures, "Partial console cleanup incomplete.");
+  };
+  try {
+    const configDir = options.configDir ?? localOperatorConfigDir();
+    const history = new ConsoleHistory(
+      path$1.join(configDir, "run", "ui-console", "history")
+    );
+    const registry = new ConsoleRegistry();
+    const completion = consoleCompletionHooks({
+      host: () => hostRef,
+      registry,
+      notifier: () => options.notifier ?? null,
+      log: log2,
+      now: options.now
+    });
+    capture = options.consoleCaptureUrl && options.preloadPath ? new ConsoleCaptureView({
+      url: options.consoleCaptureUrl,
+      preload: options.preloadPath,
+      log: log2
+    }) : null;
+    const captureView = capture;
+    if (captureView) rollbackOwners.push(() => captureView.dispose());
+    host = new ConsoleHost(registry, {
+      window: () => options.window,
+      log: log2,
+      history,
+      now: options.now,
+      // Resolved BEFORE the host exists, so no surface can be created against the
+      // launch environment and then start behaving like the user's terminal later:
+      // a surface's PATH is decided here, once, and every surface this host makes
+      // carries the same one. Bounded by the resolver's own timeout (it never
+      // rejects and answers null when the shell cannot speak), and no part of the
+      // app's own startup waits on it: the browser host is attached to the window
+      // without being awaited, so the cost of a slow rc here is this host coming
+      // online later, not the app failing to come up.
+      env: await withUserShellPath(process.env, options.userShellPath),
+      captureOffscreen: captureView ? (request) => captureView.capture(request) : void 0,
+      spawn: options.spawn ?? ((spawnOptions) => spawnPty(load.module, spawnOptions, (report) => {
+        log2(
+          `[console] restored the exec bit on ${report.path ?? "spawn-helper"}`
+        );
+      })),
+      /*
+       * ONE PUSHER, and it is A's. `broadcastConsoleState` was already the app's
+       * single "the projection moved" signal when this branch arrived; the
+       * completion seam below therefore does NOT push a second copy of the same
+       * frame. It only raises a banner, which is the half a push cannot express —
+       * and the host calls `onChanged` for a mark and an exit too, so the renderer
+       * still refetches on both (see `ConsoleHostOptions.onExit`).
+       */
+      onChanged: () => {
+        broadcastConsoleState(options.window);
+      },
+      onMark: completion.onMark,
+      onExit: completion.onExit,
+      onReveal: (request) => {
+        const window = options.window;
+        if (window.isDestroyed()) return;
+        window.webContents.send("console-reveal", {
+          surface: request.surface,
+          session_id: request.sessionId,
+          mode: request.mode
+        });
+      }
+    });
+    const ownedHost = host;
+    rollbackOwners.push(() => ownedHost.dispose(false));
+    if (options.restoreHistory !== false) {
+      const retained = history.list().sort((a, b) => b.meta.last_seen_at - a.meta.last_seen_at).slice(0, MAX_SURFACES_PER_APP);
+      for (const surface of retained) {
+        host.restore(surface.meta, surface.bytes);
+      }
+      if (retained.length > 0) {
+        log2(
+          `[console] restored ${retained.length} retained surface(s) from history; none of them is running`
+        );
+      }
     }
-    if (retained.length > 0) {
+    const collected = history.collect();
+    if (collected.removedSessions.length > 0) {
       log2(
-        `[console] restored ${retained.length} retained surface(s) from history; none of them is running`
+        `[console] history GC removed ${collected.removedSurfaces} surface(s) from ${collected.removedSessions.length} session(s) older than the window`
       );
     }
-  }
-  const collected = history.collect();
-  if (collected.removedSessions.length > 0) {
+    hostRef = host;
+    const readyHost = host;
+    registerConsoleIpc({
+      window: () => options.window,
+      expectedUrl: options.expectedUrl,
+      host: () => readyHost,
+      log: log2
+    });
     log2(
-      `[console] history GC removed ${collected.removedSurfaces} surface(s) from ${collected.removedSessions.length} session(s) older than the window`
+      `[console] host ready on the existing endpoint: ${registry.count()} surface(s) (node-pty ${helperStatus(load.helper)})`
     );
-  }
-  hostRef = host;
-  registerConsoleIpc({
-    window: () => options.window,
-    expectedUrl: options.expectedUrl,
-    host: () => host,
-    log: log2
-  });
-  log2(
-    `[console] host ready on the existing endpoint: ${registry.count()} surface(s) (node-pty ${helperStatus(load.helper)})`
-  );
-  return {
-    ok: true,
-    host,
-    registry,
-    counts: () => host.counts(),
-    dispatch: async (method, params) => {
-      if (!isConsoleDispatchMethod(method)) {
-        throw new Error(`not a console method: ${method}`);
+    return {
+      ok: true,
+      host,
+      registry,
+      counts: () => readyHost.counts(),
+      dispatch: async (method, params) => {
+        if (!isConsoleDispatchMethod(method)) {
+          throw new Error(`not a console method: ${method}`);
+        }
+        return dispatchConsole(readyHost, method, params);
+      },
+      stop: async () => {
+        unregisterConsoleIpc();
+        capture?.dispose();
+        readyHost.dispose();
+        log2("[console] host stopped");
       }
-      return dispatchConsole(host, method, params);
-    },
-    stop: async () => {
-      unregisterConsoleIpc();
-      capture?.dispose();
-      host.dispose();
-      log2("[console] host stopped");
+    };
+  } catch (error) {
+    try {
+      cleanupStartupOwners();
+    } catch (cleanupError) {
+      log2(
+        `[console] partial cleanup retained for stop: ${String(cleanupError)}`
+      );
     }
-  };
+    hostRef = null;
+    const detail = String(error);
+    log2(`[console] startup failed: ${detail}`);
+    registerRefusal("startup_failed", detail);
+    return {
+      ok: false,
+      reason: "startup_failed",
+      detail,
+      stop: async () => {
+        unregisterConsoleIpc();
+        cleanupStartupOwners();
+      }
+    };
+  }
 }
 const WEBAUTHN_GROUP_SUFFIX = ".webauthn";
 const WEBAUTHN_PROMPT_REASON = "use a passkey for $1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-operator-ui",
-  "version": "0.34.30",
+  "version": "0.34.31",
   "productName": "Local Operator",
   "description": "User interface for AI agent assistants that run Python code safely on your device through an intuitive chat interface. Supports local and cloud LLM models with built-in security features.",
   "main": "./out/main/index.js",