lazyclaw 3.99.16 → 3.99.18

package/cli.mjs

@@ -2488,13 +2488,46 @@ async function cmdChat(flags = {}) {
 // `dashboard` is the discoverable name and it auto-opens the browser
 // (which the bare daemon doesn't, since most daemon callers are
 // scripts).
+// Best-effort port-occupant kill — macOS / Linux only. Returns true when
+// at least one PID was signalled. Used by cmdDashboard so a leftover
+// listener from a previous run doesn't crash the launch with EADDRINUSE.
+// Mirrors the Python server's auto-kill behaviour described in CLAUDE.md.
+async function _killPortOccupant(port) {
+  if (process.platform === 'win32') return false;
+  const { spawn } = await import('node:child_process');
+  return new Promise((resolve) => {
+    let lsof;
+    try {
+      lsof = spawn('lsof', ['-ti', `tcp:${port}`], { stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch (_) { return resolve(false); }
+    let buf = '';
+    lsof.stdout.on('data', (d) => { buf += d.toString('utf8'); });
+    lsof.on('error', () => resolve(false));
+    lsof.on('close', () => {
+      const pids = buf.trim().split(/\s+/).map((s) => parseInt(s, 10)).filter(Number.isFinite);
+      if (!pids.length) return resolve(false);
+      // SIGTERM first so node has a chance to clean up; SIGKILL the
+      // holdouts after a short grace window.
+      for (const pid of pids) {
+        try { process.kill(pid, 'SIGTERM'); } catch (_) { /* gone already */ }
+      }
+      setTimeout(() => {
+        for (const pid of pids) {
+          try { process.kill(pid, 'SIGKILL'); } catch (_) { /* gone */ }
+        }
+        resolve(true);
+      }, 200);
+    });
+  });
+}
+
 async function cmdDashboard(flags = {}) {
   await ensureRegistry();
   const sessionsMod = await import('./sessions.mjs');
   const { startDaemon } = await import('./daemon.mjs');
   const port = flags.port !== undefined ? parseInt(flags.port, 10) : 19600;
   const cfgDir = path.dirname(configPath());
-  const d = await startDaemon({
+  const daemonOpts = {
     port,
     once: false,
     readConfig,
@@ -2508,11 +2541,45 @@ async function cmdDashboard(flags = {}) {
     // LAZYCLAW_AUTH_TOKEN + --allow-origin via the daemon command.
     authToken: undefined,
     allowedOrigins: [],
+    // The dashboard's browser tab posts back to the same loopback URL
+    // it was served from (e.g. `http://127.0.0.1:19600`). Without this
+    // opt-in every chat send / mutation tripped the daemon's CSRF gate
+    // with `403 forbidden origin`. Safe — the daemon binds 127.0.0.1
+    // only, so an attacker can't reach it with a loopback origin
+    // unless they're already on the machine.
+    allowLoopbackOrigin: true,
     rateLimit: null,
     responseCache: null,
     logger: null,
     costCap: null,
-  });
+  };
+  let d;
+  try {
+    d = await startDaemon(daemonOpts);
+  } catch (err) {
+    if (err?.code !== 'EADDRINUSE') throw err;
+    // Port is held by a leftover dashboard / daemon. Try to free it
+    // (lsof + kill on macOS/Linux); on failure, fall back to a random
+    // port so the user always gets a working dashboard rather than a
+    // crash trace.
+    const portInUse = port;
+    process.stderr.write(`  ⚠ port ${portInUse} is in use — likely a previous dashboard didn't shut down.\n`);
+    const killed = await _killPortOccupant(portInUse);
+    if (killed) {
+      process.stderr.write(`  ✓ freed port ${portInUse} (killed prior listener) — retrying…\n`);
+      // Short pause so the OS releases the port before we re-listen.
+      await new Promise(r => setTimeout(r, 250));
+      try { d = await startDaemon(daemonOpts); }
+      catch (err2) {
+        if (err2?.code !== 'EADDRINUSE') throw err2;
+        process.stderr.write(`  ⚠ still in use — falling back to a random port.\n`);
+        d = await startDaemon({ ...daemonOpts, port: 0 });
+      }
+    } else {
+      process.stderr.write(`  ⚠ couldn't free port ${portInUse} automatically — falling back to a random port.\n`);
+      d = await startDaemon({ ...daemonOpts, port: 0 });
+    }
+  }
   const url = `http://127.0.0.1:${d.port}/dashboard`;
   process.stdout.write(`🦞 LazyClaw dashboard listening at ${url}\n`);
   if (!flags['no-open']) {
@@ -2600,27 +2667,46 @@ async function cmdDaemon(flags) {
     || process.env.LAZYCLAW_WORKFLOW_STATE_DIR
     || '.workflow-state';
   const cfgDir = path.dirname(configPath());
-  const d = await startDaemon({
-    port: Number.isFinite(port) ? port : 0,
-    once,
-    readConfig,
-    // `lazyclaw daemon` exposes mutation endpoints (POST /providers,
-    // PUT /rates/<key>, etc.) only when an auth token is configured
-    // — without one the daemon is loopback-only but still untrusted
-    // (any process on the box can hit it). dashboard subcommand sets
-    // writeConfig unconditionally because it always runs as the user.
-    writeConfig: authToken ? writeConfig : undefined,
-    sessionsDirGetter: () => cfgDir,
-    sessionsMod,
-    version: () => readVersionFromRepo(),
-    workflowStateDir: () => workflowStateDirValue,
-    authToken: authToken || undefined,
-    allowedOrigins,
-    rateLimit,
-    responseCache,
-    logger,
-    costCap: costCapOrNull,
-  });
+  let d;
+  try {
+    d = await startDaemon({
+      port: Number.isFinite(port) ? port : 0,
+      once,
+      readConfig,
+      // `lazyclaw daemon` exposes mutation endpoints (POST /providers,
+      // PUT /rates/<key>, etc.) only when an auth token is configured
+      // — without one the daemon is loopback-only but still untrusted
+      // (any process on the box can hit it). dashboard subcommand sets
+      // writeConfig unconditionally because it always runs as the user.
+      writeConfig: authToken ? writeConfig : undefined,
+      sessionsDirGetter: () => cfgDir,
+      sessionsMod,
+      version: () => readVersionFromRepo(),
+      workflowStateDir: () => workflowStateDirValue,
+      authToken: authToken || undefined,
+      allowedOrigins,
+      rateLimit,
+      responseCache,
+      logger,
+      costCap: costCapOrNull,
+    });
+  } catch (err) {
+    // `lazyclaw daemon` exits cleanly on EADDRINUSE with a readable
+    // message instead of the historical unhandled-error stack trace.
+    // Unlike `lazyclaw dashboard`, daemon doesn't auto-kill the prior
+    // listener — bare daemon callers are usually scripts that expect
+    // exact port semantics, so we surface the failure and let them
+    // choose (re-run with --port 0 for random, or kill the holdout).
+    if (err?.code === 'EADDRINUSE') {
+      process.stderr.write(
+        `lazyclaw daemon: port ${port} is in use.\n` +
+        `  Re-run with --port 0 for a random port, or free the port:\n` +
+        `    lsof -ti tcp:${port} | xargs kill -9\n`
+      );
+      process.exit(2);
+    }
+    throw err;
+  }
   // Print the bound port immediately so test/script callers can pick it up
   // even when we asked for port 0. Indicate auth presence (not the token)
   // and the allowed-origin count (not the values, just whether browser

package/daemon.mjs

@@ -231,13 +231,22 @@ function isAuthorized(req, expectedToken) {
  *   - `Origin` set → must be in `allowedOrigins`. Empty allowlist
  *     means "reject all browser-originated requests" — the default,
  *     because the daemon is designed for CLI/script callers.
+ *   - `allowLoopback: true` (set by `lazyclaw dashboard`) additionally
+ *     accepts any `Origin` that looks like loopback (`http://127.0.0.1:*`,
+ *     `http://localhost:*`, `http://[::1]:*`). Safe because the daemon
+ *     binds only to 127.0.0.1, so an attacker can't reach us with a
+ *     loopback Origin unless they're already on the box. DNS rebinding
+ *     can't forge `127.0.0.1` as a hostname — that resolves before
+ *     `fetch()` ever issues the request.
  *
  * Returns true when the request should proceed, false when it should
  * be rejected with 403.
  */
-function isOriginAllowed(req, allowedOrigins) {
+const LOOPBACK_ORIGIN_RE = /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/i;
+function isOriginAllowed(req, allowedOrigins, allowLoopback) {
   const origin = req.headers['origin'];
   if (!origin) return true;
+  if (allowLoopback && LOOPBACK_ORIGIN_RE.test(origin)) return true;
   if (!allowedOrigins || allowedOrigins.length === 0) return false;
   return allowedOrigins.includes(origin);
 }
@@ -267,6 +276,10 @@ function isOriginAllowed(req, allowedOrigins) {
 export function makeHandler(ctx) {
   const authToken = ctx.authToken || null;
   const allowedOrigins = Array.isArray(ctx.allowedOrigins) ? ctx.allowedOrigins : [];
+  // dashboard subcommand opts in so the browser tab it just opened can
+  // actually call its own daemon. Bare `lazyclaw daemon` leaves this off
+  // and the explicit allowlist (or no-browser default) stays in force.
+  const allowLoopback = !!ctx.allowLoopbackOrigin;
   // Default state dir matches the CLI's default. Callers can override
   // via ctx.workflowStateDir or LAZYCLAW_WORKFLOW_STATE_DIR env var.
   const workflowStateDir = ctx.workflowStateDir
@@ -345,7 +358,7 @@ export function makeHandler(ctx) {
     try {
       // Origin gate runs *before* auth so a browser-originated request
       // can't even probe whether a token is required.
-      if (!isOriginAllowed(req, allowedOrigins)) {
+      if (!isOriginAllowed(req, allowedOrigins, allowLoopback)) {
         return writeJson(res, 403, { error: 'forbidden origin' });
       }
       // Authentication gate — when authToken is set, every request must
@@ -1666,8 +1679,19 @@ export async function startDaemon(opts) {
       setImmediate(() => server.close());
     }
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
+    // EADDRINUSE (and other listen-time errors) used to crash the
+    // process — listen() emits 'error' before the success callback
+    // fires, and we never wired that channel. Capture it once so
+    // callers (cmdDashboard / cmdDaemon) can choose to kill the
+    // occupant or fall back to a random port.
+    const onError = (err) => {
+      server.off('error', onError);
+      reject(err);
+    };
+    server.once('error', onError);
     server.listen(opts.port ?? 0, '127.0.0.1', () => {
+      server.off('error', onError);
       const addr = server.address();
       const port = typeof addr === 'object' && addr ? addr.port : 0;
       resolve({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "3.99.16",
+  "version": "3.99.18",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama and orchestrating multi-step LLM workflows. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/web/dashboard.html

@@ -523,9 +523,27 @@
     LOADERS.chat = async function loadChat() {
       try {
         const r = await api('/providers');
+        // GET /providers returns a bare array; older drafts wrapped it
+        // as { providers: [...] }. Accept both so the dashboard works
+        // against any daemon version users might happen to be running.
+        const arr = Array.isArray(r) ? r : (r.providers || []);
         const sel = document.getElementById('chat-assignee');
         sel.innerHTML = '';
-        for (const p of r.providers || []) {
+        if (arr.length === 0) {
+          const opt = document.createElement('option');
+          opt.value = ''; opt.textContent = '(no providers — run lazyclaw onboard)';
+          sel.appendChild(opt);
+          return;
+        }
+        // Preselect the configured default when possible so the user
+        // doesn't have to scroll through the list before sending the
+        // first message.
+        let defaultStatus = null;
+        try { defaultStatus = await api('/status'); } catch { /* keep going */ }
+        const defaultProv = defaultStatus?.provider || null;
+        const defaultModel = defaultStatus?.model || null;
+        const defaultValue = defaultProv && defaultModel ? `${defaultProv}:${defaultModel}` : defaultProv;
+        for (const p of arr) {
           const ms = (p.suggestedModels || []);
           if (!ms.length) {
             const opt = document.createElement('option');
@@ -540,6 +558,18 @@
             sel.appendChild(opt);
           }
         }
+        if (defaultValue) {
+          // Try exact match first (provider:model); fall back to any
+          // option starting with `<provider>:` if the configured model
+          // isn't in the suggested list.
+          const exact = Array.from(sel.options).find((o) => o.value === defaultValue);
+          if (exact) sel.value = defaultValue;
+          else {
+            const prefix = (defaultProv || '') + ':';
+            const byProv = Array.from(sel.options).find((o) => o.value.startsWith(prefix) || o.value === defaultProv);
+            if (byProv) sel.value = byProv.value;
+          }
+        }
       } catch (e) {
         document.getElementById('chat-meta').textContent = '⚠ ' + e.message;
       }