@venturewild/workspace 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venturewild/workspace",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Claude Code Web — Replit/Lovable-style chat-first browser UI that wraps the AI agent already installed on your machine.",
   "license": "MIT",
   "bin": {

package/server/src/auto-update.mjs

@@ -255,12 +255,16 @@ export class AutoUpdater {
   /**
    * One auto-update cycle, called on the supervisor's slow timer. Self-rate-limits
    * via dueForCheck so the timer cadence and the check interval are independent.
-   * Returns a short status string (exposed for tests/logging).
+   * `force` bypasses dueForCheck — used by the supervisor's post-boot kick so a
+   * RESTART always checks for updates immediately (a reboot is a rare, deliberate
+   * signal; without this a reboot within the 6h window never re-checked — why a
+   * sleepy/rebooted Mac could sit on a stale version). Returns a short status
+   * string (exposed for tests/logging).
    */
-  async tick() {
+  async tick({ force = false } = {}) {
     if (this.inProgress) return 'busy';
     if (!this.enabled()) return 'disabled';
-    if (!this.dueForCheck()) return 'not-due';
+    if (!force && !this.dueForCheck()) return 'not-due';
     this.inProgress = true;
     try {
       touchLastCheck(this.globalDir, this.nowImpl());

package/server/src/daemon-supervisor.mjs

@@ -65,6 +65,9 @@ export class DaemonSupervisor {
     this.globalDir = globalDir;
     this.pidFile = path.join(globalDir, 'daemon.pid');
     this.logFile = path.join(globalDir, 'daemon.log');
+    // Serializes concurrent ensureRunning() spawns (server + supervisor) so only
+    // one daemon is started — prevents the duplicate-daemon :8320 bind conflict.
+    this.spawnLockFile = path.join(globalDir, 'daemon-spawn.lock');
     this.resolveBinary = resolveBinary;
     this.spawnImpl = spawnImpl;
     this.fetchImpl = fetchImpl;
@@ -89,6 +92,14 @@ export class DaemonSupervisor {
   /**
    * Start the daemon unless it is already up. Idempotent and best-effort —
    * the result is reported, never thrown.
+   *
+   * Concurrency-safe: the daemon is ensured by BOTH the server (its DaemonBridge)
+   * and the always-on supervisor (daemonTick). At boot neither sees the daemon up
+   * yet, so without a guard they'd BOTH spawn → two daemons fighting over :8320
+   * (`Address already in use`) and both opening proxy links → the relay evicts one
+   * → reconnect churn. An atomic cross-process spawn lock serializes the decision:
+   * the winner re-checks health then spawns; the loser waits for the winner's
+   * daemon instead of spawning its own.
    * @returns {Promise<{started:boolean, alreadyRunning?:boolean, pid?:number,
    *   error?:string}>}
    */
@@ -96,7 +107,50 @@ export class DaemonSupervisor {
     if ((await this.health()).running) {
       return { started: false, alreadyRunning: true };
     }
-    return this.spawnDaemon();
+    if (!this.acquireSpawnLock()) {
+      // Another process (server bridge / always-on supervisor) is spawning —
+      // wait for ITS daemon rather than racing in a second one.
+      const up = await this.waitForHealthy(4000);
+      return up ? { started: false, alreadyRunning: true } : { started: false, error: 'spawn-in-progress' };
+    }
+    try {
+      // Re-check under the lock: the other caller may have just brought it up.
+      if ((await this.health()).running) {
+        return { started: false, alreadyRunning: true };
+      }
+      return this.spawnDaemon();
+    } finally {
+      this.releaseSpawnLock();
+    }
+  }
+
+  /** Is a pid alive? EPERM ("exists, not ours") still counts as alive. */
+  pidAlive(pid) {
+    try { this.killImpl(pid, 0); return true; } catch (e) { return !!(e && e.code === 'EPERM'); }
+  }
+
+  /**
+   * Atomic, cross-process spawn lock (shared globalDir, so it serializes the
+   * server and the supervisor). Returns true iff we hold it. A stale lock whose
+   * recorded pid is dead is taken over — a crash mid-spawn can't wedge it.
+   */
+  acquireSpawnLock() {
+    try { mkdirSync(this.globalDir, { recursive: true }); } catch { /* surfaced below */ }
+    try {
+      writeFileSync(this.spawnLockFile, String(process.pid), { flag: 'wx' }); // atomic exclusive create
+      return true;
+    } catch {
+      let holder = null;
+      try { holder = Number(readFileSync(this.spawnLockFile, 'utf8').trim()); } catch { /* unreadable */ }
+      if (holder && this.pidAlive(holder)) return false; // a live caller is spawning
+      try { writeFileSync(this.spawnLockFile, String(process.pid)); return true; } catch { return false; }
+    }
+  }
+
+  releaseSpawnLock() {
+    try {
+      if (Number(readFileSync(this.spawnLockFile, 'utf8').trim()) === process.pid) unlinkSync(this.spawnLockFile);
+    } catch { /* already gone */ }
   }
 
   /** Spawn the daemon detached + window-hidden, logging to `daemon.log`. */

package/server/src/supervisor.mjs

@@ -503,9 +503,9 @@ export class WorkspaceSupervisor {
     });
   }
 
-  runUpdateTick() {
+  runUpdateTick(opts = {}) {
     if (!this.autoUpdater) return;
-    this.autoUpdater.tick()
+    this.autoUpdater.tick(opts)
       .then((r) => { if (r && !['not-due', 'disabled', 'up-to-date', 'busy'].includes(r)) this.log(`auto-update tick: ${r}`); })
       .catch((e) => this.log(`auto-update error: ${e?.message || e}`));
   }
@@ -617,7 +617,10 @@ export class WorkspaceSupervisor {
         this.autoUpdater = u;
         this.updateTimer = setInterval(() => this.runUpdateTick(), this.updatePollMs);
         if (this.updateTimer.unref) this.updateTimer.unref();
-        const kick = setTimeout(() => this.runUpdateTick(), 60_000);
+        // FORCE the first post-boot check (bypass the 6h dueForCheck): a restart
+        // should always pull the latest, so a rebooted/woken machine can't sit on
+        // a stale version just because it last checked <6h ago.
+        const kick = setTimeout(() => this.runUpdateTick({ force: true }), 60_000);
         if (kick.unref) kick.unref();
       }).catch((e) => this.log(`auto-update init error: ${e?.message || e}`));
     }