@venturewild/workspace 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venturewild/workspace",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "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/canvas/core.mjs

@@ -211,6 +211,12 @@ export function createCanvas({ baseDir } = {}) {
   const dir = baseDir || defaultCanvasDir();
   const blocksFile = path.join(dir, 'blocks.json');
   const themeFile = path.join(dir, 'theme.json');
+  // Server-side persistence for canvas state (layout, templates, user-theme).
+  // Fixes the localStorage-per-origin divergence bug (req-1 gave the user two
+  // origins → two divergent canvas states for the same workspace).
+  const layoutFile = path.join(dir, 'layout.json');
+  const templatesFile = path.join(dir, 'templates.json');
+  const userThemeFile = path.join(dir, 'user-theme.json');
 
   function ensureDir() {
     try {
@@ -298,10 +304,101 @@ export function createCanvas({ baseDir } = {}) {
     return theme;
   }
 
+  // --- canvas layout (which blocks exist and where) — one file per workspace ----
+
+  function getLayout() {
+    const v = readJsonSafe(layoutFile, null);
+    return v && typeof v === 'object' ? v : null;
+  }
+
+  function saveLayout(layout) {
+    // Validate: blocks is an array, layouts has an lg array.
+    const blocks = Array.isArray(layout?.blocks) ? layout.blocks : [];
+    const lg = Array.isArray(layout?.layouts?.lg) ? layout.layouts.lg : [];
+    const data = { blocks, layouts: { lg }, ts: Date.now() };
+    ensureDir();
+    try { writeJsonAtomic(layoutFile, data); } catch { /* best-effort */ }
+    return data;
+  }
+
+  // --- user templates (saved layouts) — global per install ----
+
+  function getTemplates() {
+    const v = readJsonSafe(templatesFile, null);
+    return Array.isArray(v) ? v : [];
+  }
+
+  function saveTemplates(templates) {
+    const data = Array.isArray(templates) ? templates : [];
+    ensureDir();
+    try { writeJsonAtomic(templatesFile, data); } catch { /* best-effort */ }
+    return data;
+  }
+
+  // --- user theme (mode + accent from the picker) — separate from the agent theme ---
+  // The agent theme (theme.json) holds tokens/wallpaper set by set_theme; the user
+  // theme holds the user's own mode+accent choice from the ThemePicker. They merge
+  // at render time (mergeAgentTheme in theme.js).
+
+  function getUserTheme() {
+    const v = readJsonSafe(userThemeFile, null);
+    return v && typeof v === 'object' ? v : null;
+  }
+
+  function saveUserTheme(raw) {
+    // Only persist allowlisted fields — mode, accent, hot, accentManual, tokens.
+    const accent = hexOr(raw?.accent);
+    const theme = {
+      mode: raw?.mode === 'dark' ? 'dark' : 'light',
+      accent: accent || '#0891b2',
+      hot: hexOr(raw?.hot) || (accent ? darkenHex(accent) : '#0e7490'),
+      accentManual: !!raw?.accentManual,
+      tokens: {},
+    };
+    if (raw?.tokens && typeof raw.tokens === 'object') {
+      for (const key of TOKEN_KEYS) {
+        const hex = hexOr(raw.tokens[key]);
+        if (hex) theme.tokens[key] = hex;
+      }
+    }
+    ensureDir();
+    try { writeJsonAtomic(userThemeFile, theme); } catch { /* best-effort */ }
+    return theme;
+  }
+
+  // Darken helper (standalone — can't import from theme.js which is client-only)
+  function darkenHex(hex, f = 0.16) {
+    const h = hex.replace('#', '');
+    const k = 1 - f;
+    const c = (i) => Math.max(0, Math.min(255, Math.round(parseInt(h.slice(i, i + 2), 16) * k)));
+    return `#${[0, 2, 4].map((i) => c(i).toString(16).padStart(2, '0')).join('')}`;
+  }
+
+  // --- batch get/save (used by /api/canvas/state) ---
+
+  function getState() {
+    return {
+      layout: getLayout(),
+      templates: getTemplates(),
+      userTheme: getUserTheme(),
+    };
+  }
+
+  function saveState(updates) {
+    const result = {};
+    if (updates.layout) result.layout = saveLayout(updates.layout);
+    if (updates.templates) result.templates = saveTemplates(updates.templates);
+    if (updates.userTheme) result.userTheme = saveUserTheme(updates.userTheme);
+    return result;
+  }
+
   return {
-    dir, blocksFile, themeFile,
+    dir, blocksFile, themeFile, layoutFile, templatesFile, userThemeFile,
     listBlocks, getBlock, addBlock, updateBlock, removeBlock,
     getTheme, setTheme,
+    getLayout, saveLayout, getTemplates, saveTemplates,
+    getUserTheme, saveUserTheme,
+    getState, saveState,
   };
 }
 

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/index.mjs

@@ -1801,6 +1801,22 @@ export async function createServer(overrides = {}) {
     return c.json({ theme: canvas.getTheme() });
   });
 
+  // Canvas state — the source of truth for layout, templates, and user-theme.
+  // Fixes the localStorage-per-origin divergence (req-1 gave two origins for the
+  // same workspace → divergent canvas). Server stores the canonical state; client
+  // uses localStorage as a read-through cache.
+  app.get('/api/canvas/state', (c) => {
+    const forbidden = require(c, 'chat');
+    if (forbidden) return forbidden;
+    return c.json(canvas.getState());
+  });
+  app.post('/api/canvas/state', async (c) => {
+    const forbidden = require(c, 'chatWrite');
+    if (forbidden) return forbidden;
+    const body = await c.req.json().catch(() => ({}));
+    return c.json({ ok: true, ...canvas.saveState(body) });
+  });
+
   // The built site, served SAME-ORIGIN through this (already authed) server — no
   // squatted dev port, no mixed-content under the public proxy. The build dir
   // comes from preview.json (written by the agent's launch_preview / record_use).

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}`));
     }