@venturewild/workspace 0.6.24 → 0.6.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venturewild/workspace",
-  "version": "0.6.24",
+  "version": "0.6.27",
   "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/daemon-supervisor.mjs

@@ -26,12 +26,38 @@ import {
   writeFileSync,
   unlinkSync,
 } from 'node:fs';
+import net from 'node:net';
 import path from 'node:path';
 import os from 'node:os';
 import { resolveDaemonBinary } from './daemon-bin.mjs';
 
 const DEFAULT_HTTP_BASE = 'http://127.0.0.1:8320';
 
+/**
+ * Is something LISTENING on host:port? A successful TCP connect means the socket
+ * is still held (a new daemon would hit EADDRINUSE); ECONNREFUSED means nothing
+ * is listening — the port is FREE to bind. Loopback connects resolve instantly,
+ * so this is fast. Conservative on ambiguous outcomes (timeout / odd error):
+ * report "in use" rather than risk spawning into a half-released socket.
+ * @returns {Promise<boolean>} true = in use, false = free to bind.
+ */
+function defaultProbePort(host, port, timeoutMs = 1000) {
+  return new Promise((resolve) => {
+    const sock = net.connect({ host, port });
+    let done = false;
+    const finish = (inUse) => {
+      if (done) return;
+      done = true;
+      try { sock.destroy(); } catch { /* already closed */ }
+      resolve(inUse);
+    };
+    sock.setTimeout(timeoutMs);
+    sock.once('connect', () => finish(true)); //  someone is listening
+    sock.once('timeout', () => finish(true)); //  filtered/hung — assume held
+    sock.once('error', (e) => finish(e?.code !== 'ECONNREFUSED')); // refused = free
+  });
+}
+
 export class DaemonSupervisor {
   /**
    * @param {object} [opts]
@@ -53,6 +79,7 @@ export class DaemonSupervisor {
     spawnImpl = spawn,
     fetchImpl = globalThis.fetch,
     killImpl = (pid, sig) => process.kill(pid, sig),
+    probePortImpl = defaultProbePort, // (host, port, timeoutMs) -> Promise<bool>; test seam
     env = process.env,
     // b-ii: when the install is logged in (account.json present), these are
     // injected into the daemon's spawn env so it opens the proxy link
@@ -72,6 +99,7 @@ export class DaemonSupervisor {
     this.spawnImpl = spawnImpl;
     this.fetchImpl = fetchImpl;
     this.killImpl = killImpl;
+    this.probePortImpl = probePortImpl;
     this.env = env;
     this.accountToken = accountToken;
     this.serverUrl = serverUrl;
@@ -246,18 +274,52 @@ export class DaemonSupervisor {
     return { stopped: true, pid };
   }
 
+  /** The daemon's API host+port, parsed from httpBase (for raw socket checks). */
+  get apiHostPort() {
+    try {
+      const u = new URL(this.httpBase);
+      return { host: u.hostname || '127.0.0.1', port: Number(u.port) || 8320 };
+    } catch {
+      return { host: '127.0.0.1', port: 8320 };
+    }
+  }
+
+  /** Is the daemon's API port still held by a listener? (true = can't bind yet) */
+  portInUse(timeoutMs = 1000) {
+    const { host, port } = this.apiHostPort;
+    return this.probePortImpl(host, port, timeoutMs);
+  }
+
+  /**
+   * Block until the daemon's API port is FREE to bind, or the deadline passes.
+   * Returns true if it became free, false on timeout (caller proceeds anyway —
+   * best-effort, like the old health-poll).
+   */
+  async waitForPortFree(timeoutMs = 8000, pollMs = 150) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+      if (!(await this.portInUse())) return true;
+      if (Date.now() >= deadline) return false;
+      await new Promise((r) => setTimeout(r, pollMs));
+    }
+  }
+
   /**
    * Recycle the daemon so it loads a freshly-resolved binary (after an
-   * auto-update). Stop the running process, wait for it to release its API port,
-   * then spawn again. Returns the `spawnDaemon` result.
+   * auto-update). Stop the running process, wait for it to release its API
+   * SOCKET, then spawn again. Returns the `spawnDaemon` result.
+   *
+   * Why wait on the socket, not health(): health() going false only means the
+   * daemon stopped answering HTTP — the OS can hold the :8320 listening socket a
+   * beat longer (graceful-shutdown drain / close). The daemon does NOT retry its
+   * bind: it logs "Address already in use" once and gives up, so the b-ii proxy
+   * link never forms and the public URL stays 502 until a reboot
+   * (docs/onboarding-hardening-2026-06-23.md). Spawning only once the socket is
+   * actually free closes that race.
    */
   async recycle() {
     await this.stop();
-    // Wait for the old process to exit + free :PORT, else the new one can't bind.
-    const deadline = Date.now() + 5000;
-    while (Date.now() < deadline && (await this.health()).running) {
-      await new Promise((r) => setTimeout(r, 200));
-    }
+    await this.waitForPortFree();
     return this.spawnDaemon();
   }
 

package/server/src/index.mjs

@@ -87,6 +87,7 @@ import { runDoctor } from './doctor.mjs';
 import { appendLine, tailFile, logFile, listLogs, TAILABLE, globalDir } from './logpaths.mjs';
 import { createBackgroundTasks } from './background-tasks.mjs';
 import { createTickets } from './support/tickets.mjs';
+import { createTicketSyncer } from './support/ticket-sync.mjs';
 import { SessionReporter } from './session-reporter.mjs';
 import { TranscriptRecorder } from './transcript.mjs';
 import { loadObservabilityConsent, setObservabilityConsent } from './observability.mjs';
@@ -648,6 +649,14 @@ export async function createServer(overrides = {}) {
       .finally(() => clearTimeout(t));
   }
 
+  // Dedup'd push to the team's rails. Swept at every turn end AND by the Requests-block
+  // poll — so a ticket the agent files via mcp__tickets__file_ticket (a separate process
+  // that only writes the local store, never calls syncTicket) still reaches the team
+  // without the user having the Requests block open. See support/ticket-sync.mjs.
+  const ticketSync = createTicketSyncer({ send: syncTicket, list: () => tickets.list() });
+  const syncTicketOnce = (rec) => ticketSync.syncOnce(rec);
+  const syncUnsyncedTickets = () => ticketSync.syncAll();
+
   /**
    * Run one chat turn: spawn the agent, stream every chunk to every chat
    * client, and persist the resulting session id so the next turn resumes it.
@@ -810,6 +819,10 @@ export async function createServer(overrides = {}) {
         } catch { /* best-effort — never break a turn on a registry hiccup */ }
         broadcastChat({ type: 'end', messageId: id, code }, workspace.id, threadId);
         activityBus.publish({ type: 'chat-end', messageId: id, code });
+        // A user turn may have filed/updated a ticket via mcp__tickets__file_ticket
+        // (a separate process that only writes the local store). Sweep + push them to
+        // the team now, so agent-filed tickets sync without the user opening Requests.
+        if (!auto) syncUnsyncedTickets();
       });
       session.send(prompt, {
         cwd: workspace.dir,
@@ -2813,15 +2826,13 @@ export async function createServer(overrides = {}) {
   // --- Feature/bug tickets (item 7) — the Requests block + the agent's file_ticket --
   // The agent files via the support MCP (mcp__tickets__file_ticket) into the same
   // store; the user files/updates here. Owner-gated. Tickets sync to the team's tracker
-  // best-effort, once each (a runaway list-poll never re-POSTs the same ticket).
-  const syncedTicketIds = new Set();
+  // best-effort, once each via syncTicketOnce/syncUnsyncedTickets (defined up top, also
+  // swept at every turn end so agent-filed tickets sync without opening this block).
   app.get('/api/workspace/tickets', (c) => {
     const forbidden = require(c, 'chatWrite');
     if (forbidden) return forbidden;
     const list = tickets.list();
-    for (const t of list) {
-      if (!syncedTicketIds.has(t.id)) { syncedTicketIds.add(t.id); syncTicket(t); }
-    }
+    for (const t of list) syncTicketOnce(t);
     return c.json({ tickets: list });
   });
   app.post('/api/workspace/tickets', async (c) => {
@@ -2833,7 +2844,7 @@ export async function createServer(overrides = {}) {
       title: body.title, desc: body.desc, category: body.category, severity: body.severity,
       workspaceId: workspaceFor(c).id, source: 'user',
     });
-    syncedTicketIds.add(rec.id); syncTicket(rec);
+    syncTicketOnce(rec);
     auditAction(c, 'tickets.file', `id=${rec.id} cat=${rec.category}`);
     return c.json({ ticket: rec });
   });
@@ -2843,7 +2854,7 @@ export async function createServer(overrides = {}) {
     const body = await c.req.json().catch(() => ({}));
     const rec = tickets.update(c.req.param('id'), { status: body.status, note: body.note });
     if (!rec) return c.json({ error: 'not_found' }, 404);
-    syncTicket(rec);
+    syncTicketOnce(rec);
     auditAction(c, 'tickets.update', `id=${rec.id} status=${rec.status}`);
     return c.json({ ticket: rec });
   });

package/server/src/support/mcp-server.mjs

@@ -80,7 +80,7 @@ async function callTool(name, args = {}) {
       });
       return textContent({
         kind: 'ticket', op: 'file', ticket: rec,
-        note: "Request filed. It's on the user's Requests block + synced to VentureWild. Tell them in one short line what you logged.",
+        note: "Request filed to the user's Requests block; the server reports it to the VentureWild team when this turn ends. Tell them in one short line what you logged.",
       });
     }
     case 'list_tickets': {

package/server/src/support/ticket-sync.mjs

@@ -0,0 +1,44 @@
+// Dedup wrapper around the best-effort "push a ticket to the team's rails" send.
+//
+// The bug this fixes: a ticket the agent files via mcp__tickets__file_ticket lands in
+// the local store from a SEPARATE process that never calls the server's syncTicket — so
+// it only reached the rails when the web Requests block happened to poll. This syncer is
+// swept at the end of every chat turn (and from the poll), so agent-filed tickets sync
+// without the user opening anything.
+//
+// Dedup key = id + updatedAt + status + note-count, so each ticket VERSION is sent at
+// most once, but a later change re-sends. We include status/note-count (not just
+// updatedAt) because two writes can land in the SAME millisecond — an agent that files
+// then immediately updates a ticket would otherwise collide on updatedAt and the change
+// would never sync. Re-sending is safe: the rails ingest upserts by ticket_id. The
+// `sent` set is in-memory — a server restart re-syncs the store on the next sweep.
+
+export function createTicketSyncer({ send, list }) {
+  const sent = new Set();
+
+  function sig(rec) {
+    const notes = Array.isArray(rec.notes) ? rec.notes.length : 0;
+    return `${rec.id}:${rec.updatedAt || rec.createdAt || 0}:${rec.status || ''}:${notes}`;
+  }
+
+  // Send one ticket if this version hasn't been sent yet. Returns true if it sent.
+  function syncOnce(rec) {
+    if (!rec || typeof rec.id !== 'string') return false;
+    const key = sig(rec);
+    if (sent.has(key)) return false;
+    sent.add(key);
+    try { send(rec); } catch { /* best-effort — the local store is the source of truth */ }
+    return true;
+  }
+
+  // Sweep the whole store, sending every not-yet-sent version. Returns how many sent.
+  function syncAll() {
+    let recs;
+    try { recs = list() || []; } catch { return 0; }
+    let n = 0;
+    for (const r of recs) { if (syncOnce(r)) n += 1; }
+    return n;
+  }
+
+  return { syncOnce, syncAll };
+}