@venturewild/workspace 0.6.23 → 0.6.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venturewild/workspace",
-  "version": "0.6.23",
+  "version": "0.6.26",
   "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/bin/wild-workspace.mjs

@@ -18,7 +18,7 @@ import {
 } from '../src/account.mjs';
 import { readFileSync } from 'node:fs';
 import { WorkspaceSupervisor, probeHealth } from '../src/supervisor.mjs';
-import { installService, uninstallService, serviceStatus, globalDir } from '../src/service.mjs';
+import { installService, startService, uninstallService, serviceStatus, globalDir } from '../src/service.mjs';
 import { appendLine, listLogs, tailFile } from '../src/logpaths.mjs';
 import { runDoctor, renderDoctor, writeDoctorBundle } from '../src/doctor.mjs';
 import { enableOperator, disableOperator, operatorStatus } from '../src/operator.mjs';
@@ -281,16 +281,28 @@ async function runLoginCommand(args) {
   console.log(`  url       : https://${saved.slug}.venturewild.llc  (once the tunnel is configured)`);
   console.log(`  saved to  : ${config.dataDir}/account.json`);
   console.log('');
-  console.log('Run `wild-workspace` in any folder to start your workspace.');
 
-  // Arm always-on so the workspace comes back on its own (best-effort — never
-  // blocks login). On a platform without autostart yet, just nudge the user.
+  // Arm always-on AND start it now (best-effort — never blocks login) so a brand-new
+  // user gets a LIVE workspace without logging out/in. installService writes the
+  // autostart entry; startService brings the supervisor up immediately (idempotent —
+  // no-ops if one already holds the lock). Everything is driven by absolute paths, so
+  // the bare `wild-workspace` command never needs to be on PATH.
   try {
     const svc = await installService({
       node: process.execPath, cli: __filename, workspaceDir: config.workspaceDir, port: config.port, version: APP_VERSION,
     });
-    if (svc.installed) console.log('  always-on : enabled — starts at login (disable: wild-workspace service uninstall)');
-    else if (svc.supported === false) console.log(`  always-on : not yet on ${svc.platform} — run \`wild-workspace\` to start it`);
+    if (svc.installed) {
+      const started = await startService({}).catch(() => ({ started: false }));
+      if (started.started || started.alreadyRunning) {
+        console.log('  always-on : ON — starting your workspace now; it relaunches at every login.');
+        console.log('');
+        console.log(`Your workspace is coming up at https://${saved.slug}.venturewild.llc — give it a few seconds.`);
+      } else {
+        console.log('  always-on : enabled — starts at your next login (disable: wild-workspace service uninstall)');
+      }
+    } else if (svc.supported === false) {
+      console.log(`  always-on : not yet automated on ${svc.platform}.`);
+    }
   } catch { /* never block login */ }
 }
 
@@ -926,6 +938,18 @@ async function runServiceCommand(action = 'status', opts = {}) {
     return;
   }
 
+  if (action === 'start') {
+    // Bring always-on UP now (the bootstrap installer calls this after `install` so a
+    // brand-new user gets a live workspace without logging out/in). Idempotent.
+    const r = await startService({});
+    if (r.supported === false) { console.log(`service: start not supported on ${r.platform} yet — run \`wild-workspace\` manually`); return; }
+    if (r.alreadyRunning) { console.log('always-on: already running.'); return; }
+    if (r.started) { console.log(`✓ always-on started (${r.method}) — your workspace is coming up now.`); return; }
+    console.log(`service start: couldn't start${r.reason ? ` — ${r.reason}` : r.error ? ` — ${r.error}` : ''} (run \`wild-workspace service install\` first?).`);
+    process.exitCode = 1;
+    return;
+  }
+
   if (action === 'uninstall') {
     const r = await uninstallService();
     if (r.supported === false) { console.log(`service: nothing to do — autostart not implemented for ${r.platform} yet`); return; }
@@ -958,7 +982,7 @@ async function runServiceCommand(action = 'status', opts = {}) {
     return;
   }
 
-  console.log(`unknown service action: ${action}  (use install | uninstall | status | run)`);
+  console.log(`unknown service action: ${action}  (use install | start | uninstall | status | run)`);
 }
 
 async function main() {

package/server/src/agent.mjs

@@ -466,3 +466,22 @@ export function pickDefaultAgent(detected) {
   if (anyAvailable) return anyAvailable;
   return detected[0] || DEFAULT_AGENTS[0];
 }
+
+// Re-pick the active agent from a FRESH detection, used by the readiness gate's
+// "I installed it / signed in" retry. THE BUG THIS FIXES: detection runs once at
+// startup, so a brand-new user who installs Claude AFTER the workspace booted was
+// stuck — the gate kept saying "missing"/"login" until a full restart, because the
+// frozen `activeAgent` stayed `available:false`. Re-detecting on retry flips it.
+//
+// We REFRESH the currently-active agent (so a deliberate switch to GLM/Codex isn't
+// clobbered back to the default) and only re-pick the default when the current
+// agent is gone or still unavailable. Never invents availability — a still-missing
+// agent stays missing, so the gate can't false-pass.
+export function refreshActiveAgent(detected, current) {
+  const list = Array.isArray(detected) ? detected : [];
+  if (current) {
+    const same = list.find((a) => a.id === current.id);
+    if (same && same.available) return same;
+  }
+  return pickDefaultAgent(list);
+}

package/server/src/index.mjs

@@ -21,7 +21,7 @@ import {
   assertSecureBinding,
   isLocalhost,
 } from './config.mjs';
-import { detectAgents, AgentSession, pickDefaultAgent } from './agent.mjs';
+import { detectAgents, AgentSession, pickDefaultAgent, refreshActiveAgent } from './agent.mjs';
 import {
   mintShareToken,
   mintDeviceToken,
@@ -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,
@@ -1541,6 +1554,20 @@ export async function createServer(overrides = {}) {
     if (!fresh && _readinessCache && now - _readinessCache.at < READINESS_TTL_MS) {
       return c.json({ agent: agentTag(activeAgent), ...(_readinessCache.verdict) });
     }
+    // On a forced refresh (the gate's "I installed it / signed in" button), RE-DETECT
+    // agents BEFORE probing. A brand-new user installs Claude AFTER the workspace
+    // booted; detection is otherwise frozen at startup, so the gate stayed stuck on
+    // "missing"/"login" until a full restart (the exact "I installed it but it still
+    // says missing" trap). refreshActiveAgent keeps a deliberately-chosen agent and
+    // only flips a now-installed binary to available — it never false-passes.
+    if (fresh) {
+      try {
+        const redetected = (await operatorDeps.detectAgents()) || [];
+        activeAgent = refreshActiveAgent(redetected, activeAgent);
+      } catch (e) {
+        log('[onboarding]', `readiness re-detect failed: ${e?.message || e}`);
+      }
+    }
     const verdict = await probeAgentReadiness(activeAgent);
     _readinessCache = { at: now, verdict };
     log('[onboarding]', `readiness agent=${activeAgent?.id || '-'} status=${verdict.status}${verdict.email ? ` email=${verdict.email}` : ''}`);
@@ -2799,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) => {
@@ -2819,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 });
   });
@@ -2829,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/service.mjs

@@ -453,6 +453,76 @@ export async function installService(opts = {}, deps = {}) {
   return unsupported(platform, 'installed');
 }
 
+// Bring the installed always-on supervisor UP NOW, rather than waiting for the next
+// login. `installService` deliberately does NOT auto-start (a manually-run
+// `wild-workspace` could already hold :5173, and starting a second server collides).
+// But the BOOTSTRAP installer runs in a CLEAN context — nothing on the port — so it
+// follows `service install` with `service start` so a brand-new user gets a live URL
+// without logging out/in. IDEMPOTENT: if a supervisor already holds the singleton
+// lock we no-op, so a redundant start (or an existing user) never double-starts.
+export async function startService(opts = {}, deps = {}) {
+  const platform = deps.platform || process.platform;
+  const dir = deps.dir || globalDir();
+  const { supervisorAlive } = supervisorLiveness(dir);
+  if (supervisorAlive) return { started: false, alreadyRunning: true, platform };
+  if (platform === 'darwin') {
+    return macStart(
+      { uid: deps.uid ?? currentUid() },
+      { launchAgentsDir: deps.launchAgentsDir || defaultLaunchAgentsDir(), execFileImpl: deps.execFileImpl || execFileP },
+    );
+  }
+  if (platform === 'linux') {
+    return linuxStart({}, { execFileImpl: deps.execFileImpl || execFileP });
+  }
+  if (platform === 'win32') {
+    return winStart({ dir }, { spawnImpl: deps.spawnImpl || spawn });
+  }
+  return unsupported(platform, 'started');
+}
+
+async function macStart({ uid }, { launchAgentsDir, execFileImpl }) {
+  const plist = plistPath(launchAgentsDir);
+  if (!fs.existsSync(plist)) return { started: false, reason: 'not-installed', platform: 'darwin' };
+  const domain = `gui/${uid}`;
+  // bootstrap LOADS the agent → RunAtLoad starts it. If it's already loaded from a
+  // prior login, bootstrap errors → kickstart it instead to force a (re)start.
+  try {
+    await execFileImpl('launchctl', ['bootstrap', domain, plist]);
+    return { started: true, method: 'launchctl-bootstrap', platform: 'darwin' };
+  } catch {
+    try {
+      await execFileImpl('launchctl', ['kickstart', '-k', `${domain}/${LAUNCHD_LABEL}`]);
+      return { started: true, method: 'launchctl-kickstart', platform: 'darwin' };
+    } catch (e) {
+      return { started: false, error: String(e?.message || e).split('\n')[0], platform: 'darwin' };
+    }
+  }
+}
+
+async function linuxStart(_opts, { execFileImpl }) {
+  try {
+    await execFileImpl('systemctl', ['--user', 'start', SYSTEMD_UNIT]);
+    return { started: true, method: 'systemctl-start', platform: 'linux' };
+  } catch (e) {
+    return { started: false, error: String(e?.message || e).split('\n')[0], platform: 'linux' };
+  }
+}
+
+function winStart({ dir }, { spawnImpl }) {
+  // Launch the same hidden VBS that HKCU\Run uses, detached, so the supervisor comes
+  // up now AND outlives this process. (At next login HKCU\Run launches another; the
+  // singleton lock makes it exit — no respawn loop, since HKCU\Run is one-shot.)
+  const vbs = path.join(dir, 'launch-hidden.vbs');
+  if (!fs.existsSync(vbs)) return { started: false, reason: 'not-installed', platform: 'win32' };
+  try {
+    const child = spawnImpl('wscript.exe', [vbs], { detached: true, stdio: 'ignore', windowsHide: true });
+    if (child && typeof child.unref === 'function') child.unref();
+    return { started: true, method: 'wscript-vbs', platform: 'win32' };
+  } catch (e) {
+    return { started: false, error: String(e?.message || e).split('\n')[0], platform: 'win32' };
+  }
+}
+
 export async function uninstallService(deps = {}) {
   const platform = deps.platform || process.platform;
   if (platform === 'win32') {

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 };
+}