@venturewild/workspace 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venturewild/workspace",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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

@@ -684,6 +684,24 @@ async function main() {
     return;
   }
 
+  // If a workspace server is already serving this port — always-on started it at
+  // login, or another `wild-workspace` is running — don't fight it for the socket
+  // (createServer would reject on EADDRINUSE and crash). Just open the browser to
+  // the one already up. This is the common case now that always-on is real.
+  {
+    const probeCfg = buildConfig(opts);
+    if (await probeHealth(probeCfg.port)) {
+      const host = probeCfg.host === '0.0.0.0' ? '127.0.0.1' : probeCfg.host;
+      const url = `http://${host}:${probeCfg.port}`;
+      console.log(`\n  wild-workspace is already running at ${url}`);
+      if (probeCfg.openBrowser) {
+        console.log('  opening it in your browser…');
+        try { const open = (await import('open')).default; await open(url); } catch { /* best-effort */ }
+      }
+      return;
+    }
+  }
+
   const server = await createServer(opts);
   const { config } = server;
   console.log(`\n  wild-workspace v${APP_VERSION}`);

package/server/src/agent.mjs

@@ -19,21 +19,51 @@ import { spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { execFile as execFileCb } from 'node:child_process';
 import { EventEmitter } from 'node:events';
+import os from 'node:os';
+import fs from 'node:fs';
 import { DEFAULT_AGENTS } from './config.mjs';
 
 const execFile = promisify(execFileCb);
 
 const PATH_LOOKUP_TIMEOUT_MS = 1500;
 
+// Where `claude` (and other user-installed CLIs) actually live on macOS/Linux.
+// The native installer drops it in ~/.local/bin; Homebrew uses /opt/homebrew/bin
+// (Apple Silicon) or /usr/local/bin; our no-sudo npm prefix is ~/.npm-global/bin.
+function toolDirs(home = os.homedir()) {
+  return [`${home}/.local/bin`, '/opt/homebrew/bin', '/usr/local/bin', `${home}/.npm-global/bin`];
+}
+
+// GUI / launchd-launched processes inherit a MINIMAL PATH that omits all of the
+// above and never reads ~/.zshrc — so a server started by the macOS always-on
+// LaunchAgent can't find `claude` (spawn ENOENT). Idempotently add the real tool
+// dirs so detection + spawn work regardless of how the process was launched.
+export function ensureToolPath(env = process.env, { platform = process.platform, home = os.homedir() } = {}) {
+  if (platform === 'win32') return env.PATH; // HKCU\Run inherits the full user PATH
+  const have = (env.PATH || '').split(':').filter(Boolean);
+  const add = toolDirs(home).filter((d) => !have.includes(d));
+  if (add.length) env.PATH = [...have, ...add].join(':');
+  return env.PATH;
+}
+
 async function isOnPath(binary) {
+  ensureToolPath(); // make sure the tool dirs are on PATH before we look
   const probe = process.platform === 'win32' ? 'where.exe' : 'which';
   try {
     const { stdout } = await execFile(probe, [binary], { timeout: PATH_LOOKUP_TIMEOUT_MS });
     const lines = stdout.split(/\r?\n/).filter(Boolean);
-    return lines.length > 0 ? lines[0].trim() : null;
-  } catch {
-    return null;
+    if (lines.length > 0) return lines[0].trim();
+  } catch { /* fall through to a direct probe */ }
+  // which/where can still miss a freshly-installed binary in a stripped launchd
+  // environment — probe the known install dirs directly and return an ABSOLUTE
+  // path, which spawn uses verbatim (no PATH needed at spawn time).
+  if (process.platform !== 'win32') {
+    for (const dir of toolDirs()) {
+      const candidate = `${dir}/${binary}`;
+      try { fs.accessSync(candidate, fs.constants.X_OK); return candidate; } catch { /* next */ }
+    }
   }
+  return null;
 }
 
 export async function detectAgents(candidates = DEFAULT_AGENTS) {

package/server/src/index.mjs

@@ -581,18 +581,16 @@ export async function createServer(overrides = {}) {
 
   // In-app "Sign in to Claude" — drives `claude auth login` in a real PTY so the
   // browser OAuth callback auto-completes and the user never touches a terminal.
-  // (See agent-login.mjs.) Degrades to `{status:'unsupported'}` if node-pty is
-  // absent, and the gate falls back to the terminal instruction. The OAuth URL is
-  // opened on this machine — the server runs locally, so it's the user's browser.
+  // (See agent-login.mjs.) Claude opens the OAuth URL in the user's browser itself
+  // (the server is local), so we do NOT open it again here — doing so spawned a
+  // duplicate tab; the UI surfaces the captured URL as a "didn't open?" fallback.
+  // Degrades to `{status:'unsupported'}` if node-pty is absent (gate → terminal).
   let _loginSession = null;
-  const openUrl = async (u) => {
-    try { const open = (await import('open')).default; await open(u); } catch { /* best-effort */ }
-  };
   const emptyLoginSnap = { status: 'idle', url: null, error: null, verdict: null };
   app.post('/api/agent/login/start', async (c) => {
     const forbidden = require(c, 'chatWrite');
     if (forbidden) return forbidden;
-    if (!_loginSession) _loginSession = new ClaudeLoginSession({ agent: activeAgent, openImpl: openUrl });
+    if (!_loginSession) _loginSession = new ClaudeLoginSession({ agent: activeAgent });
     _loginSession.agent = activeAgent; // track the active agent if it changed
     const snap = await _loginSession.start();
     _readinessCache = null; // a sign-in is about to change auth state — don't serve stale