local-operator-ui 0.30.3 → 0.30.4

package/out/main/index.js

@@ -5773,6 +5773,16 @@ class DaemonStateMachine {
         this.state = "attached";
         this.detail = this.identity ? `Connected to the daemon on ${this.identity.url} (pid ${this.identity.pid}, v${this.identity.version}).` : "Connected to the Local Operator daemon.";
         break;
+      case "reanchored":
+        this.identity = observation.identity;
+        this.failures = 0;
+        this.unanswered = 0;
+        this.capabilityStatus = null;
+        this.detachedSince = null;
+        this.backoffMs = REATTACH_BACKOFF_MS;
+        this.state = "attached";
+        this.detail = observation.detail;
+        break;
       case "capability":
         this.capabilityStatus = observation.status;
         this.detail = `${observation.detail} The daemon is running.`;
@@ -8876,8 +8886,16 @@ class BackendServiceManager {
     const probe = await probeIdentity(this.backendUrl, expected, {
       timeoutMs: PROBE_TIMEOUT_MS
     });
-    const answersThisApp = probe.outcome === "identified" && probe.identity.pid === this.daemonState.snapshot().pid;
-    const answeredAnotherProcess = probe.outcome === "identity-mismatch" || probe.outcome === "not-a-daemon" || probe.outcome === "identified";
+    const attachedPid = this.daemonState.snapshot().pid;
+    const reanchored = probe.outcome === "identity-mismatch" && attachedPid !== null && probe.identity.pid === attachedPid && this.holdsLiveChildProcess(attachedPid) ? (
+      // Spread rather than field by field: this value IS `probe.identity` plus the
+      // address. A field added to `DaemonIdentity` later must not have to be
+      // remembered in this one literal, where it would silently take the widened
+      // type's `undefined` instead of the answering value.
+      { ...probe.identity, url: this.backendUrl }
+    ) : null;
+    const answersThisApp = reanchored !== null || probe.outcome === "identified" && probe.identity.pid === this.daemonState.snapshot().pid;
+    const answeredAnotherProcess = reanchored === null && (probe.outcome === "identity-mismatch" || probe.outcome === "not-a-daemon" || probe.outcome === "identified");
     if (answersThisApp) {
       this.daemonState.setPairing(DAEMON_PAIRED);
     } else if (answeredAnotherProcess) {
@@ -8893,6 +8911,13 @@ class BackendServiceManager {
           detail: "The answering daemon's PID no longer matches the attachment."
         };
       case "identity-mismatch":
+        if (reanchored) {
+          return {
+            kind: "reanchored",
+            identity: reanchored,
+            detail: `Connected to the daemon on ${this.backendUrl} (pid ${reanchored.pid}, v${reanchored.version}). It reloaded in place and kept the same process.`
+          };
+        }
         return {
           kind: "contradicted",
           detail: `Another process is answering at ${this.backendUrl} (${probe.detail})`
@@ -9019,7 +9044,7 @@ class BackendServiceManager {
     try {
       if (this.daemonState.expectedInstanceId()) {
         const observation = await this.probeAttachedDaemon();
-        if (observation.kind === "identified") {
+        if (observation.kind === "identified" || observation.kind === "reanchored") {
           this.daemonState.observe(observation);
           this.nextRecoveryAt = 0;
           this.notifyStatus();
@@ -9068,6 +9093,36 @@ class BackendServiceManager {
   getOwnedPid() {
     return this.process?.pid ?? null;
   }
+  /**
+   * Whether `pid` is the process this app spawned and that process is still live.
+   *
+   * The three clauses are one statement - "this is my child, and it has not
+   * exited" - and each is load-bearing:
+   *
+   *  - the handle is the proof of identity. A `ChildProcess` is only ever built by
+   *    this manager's own `spawn()`, so its `pid` cannot be a number read off a
+   *    record that something else wrote, and it cannot be recycled: the OS does not
+   *    reuse a pid while the process it names is alive, and a reused one means THIS
+   *    child exited - which the `exitCode` clause reads. That reading is Node's
+   *    RECORDED exit, set when the process event arrives rather than when the process
+   *    dies, so a pid recycled inside the window before it is recorded would pass
+   *    here. It is the same window the recovery guard accepts, and the caller that
+   *    matters (the reload re-anchor) needs the answering pid to be bound to this
+   *    app's own port as well, which is why this is stated rather than hedged.
+   *  - `exitCode === null && signalCode == null` is the same liveness spelling
+   *    `stop()` and the recovery guard act on (see `ownedPid`'s note), so a process
+   *    this app has already reaped is never treated as live by one caller and dead
+   *    by another;
+   *  - a `null` pid is not a match. A manager that has never spawned anything owns
+   *    nothing, and `undefined === undefined` must not read as ownership.
+   *
+   * Used by the reload re-anchor in `probeAttachedDaemon`, which is the one place
+   * this app decides that a changed `instance_id` belongs to the process it
+   * already holds rather than to a successor.
+   */
+  holdsLiveChildProcess(pid) {
+    return pid !== null && this.process !== null && this.process.pid === pid && this.process.exitCode === null && this.process.signalCode == null;
+  }
   /**
    * The install SERVING this app, read from the serving process's own record.
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-operator-ui",
-  "version": "0.30.3",
+  "version": "0.30.4",
   "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",