ava-engine 0.2.0 → 0.4.0

package/server.mjs

@@ -12,8 +12,13 @@ import { oursTurnStream, greetStream, observeUpdate, screenOff, proactiveNudge,
 import { synth, TTS_ENABLED, providers, defaultProvider, warmKokoro, kokoroStream, KOKORO_STREAMS, elevenStream, ELEVEN_STREAMS, TtsBusyError } from "./lib/tts.mjs";
 import { transcribe, STT_ENABLED } from "./lib/stt.mjs";
 import { createAsrSession, asrAvailable, warmAsr, availableEngines, defaultEngine, ENGINE_LABELS } from "./lib/asr.mjs";
-import { platformsView, platformById } from "./lib/platforms.mjs";
-import { AUTH_ENABLED, isAuthorized, challengeHeaders, authCookieHeader, clientIp, sameOrigin, limiter } from "./lib/guard.mjs";
+import { platformsView, platformById, CUSTOM_PLAYBOOKS } from "./lib/platforms.mjs";
+import { AUTH_ENABLED, isAuthorized, currentUser, signIn, logoutCookie, authCookieHeader, clientIp, sameOrigin, limiter } from "./lib/guard.mjs";
+import { hasUsers } from "./lib/team.mjs";
+import { emitEvent, WEBHOOKS_ENABLED } from "./lib/webhooks.mjs";
+import { DAILY_BUDGET_USD, dailyCapReached, spentToday } from "./lib/spend.mjs";
+import { getLink, linkBlocked, countLinkCall, publicLinkView, linkCookieHeader, linksFromRequest } from "./lib/links.mjs";
+import { createAdmin } from "./lib/admin.mjs";
 import { WebSocketServer } from "ws";
 
 // A stray rejection is logged, not fatal. An uncaught exception leaves the process
@@ -24,25 +29,33 @@ process.on("uncaughtException", (e) => { console.error("[uncaught exception]", e
 const __dir = dirname(fileURLToPath(import.meta.url));
 const PUBLIC = join(__dir, "public");
 const PORT = Number(process.env.PORT) || 5190;
+// HOST=127.0.0.1 keeps Ava private to this computer (the CLI's "just me" setup).
+const HOST = process.env.HOST || undefined;
+const LOCAL_ONLY = HOST === "127.0.0.1" || HOST === "localhost" || HOST === "::1";
 
 // Spend limits. Each session is capped in model spend; each client IP in request rate.
-const SESSION_BUDGET_USD = Number(process.env.SESSION_BUDGET_USD) || 2;
+const sessionBudget = () => Number(process.env.SESSION_BUDGET_USD) || 2; // live: editable in Settings
 const MAX_USER_TEXT = 2000;
 const MAX_FRAME_BYTES = 2 * 1024 * 1024; // a downscaled JPEG screen frame is ~100-300 KB
 const FRAME_RE = /^data:image\/(jpeg|png|webp);base64,[A-Za-z0-9+/=]+$/;
 const rate = {
-  session: limiter("session", Number(process.env.RATE_SESSIONS_PER_MIN) || 10, 60_000), // new calls per IP per minute
-  api: limiter("api", Number(process.env.RATE_API_PER_MIN) || 240, 60_000),            // all other /api calls per IP per minute
+  session: limiter("session", () => Number(process.env.RATE_SESSIONS_PER_MIN) || 10, 60_000), // new calls per IP per minute
+  api: limiter("api", () => Number(process.env.RATE_API_PER_MIN) || 240, 60_000),            // all other /api calls per IP per minute
   authFail: limiter("authFail", 20, 10 * 60_000),                                         // wrong passwords per IP per 10 minutes
 };
 
 // A wrong password counts against the client; past the limit, stop checking.
 // (A first visit with no credentials at all is just the login prompt, not a guess.)
-const triedPassword = (req) => !!req.headers.authorization || /ava_auth=/.test(String(req.headers.cookie || ""));
+const triedPassword = (req) => !!req.headers.authorization || /ava_session=/.test(String(req.headers.cookie || ""));
 function lockedOut(req) { return triedPassword(req) && rate.authFail.blocked(clientIp(req)); }
-function denyAuth(req, res) {
+// Pages go to the sign-in page (and come back after); API calls get a 401.
+function denyAuth(req, res, url) {
   if (triedPassword(req)) rate.authFail(clientIp(req));
-  return send(res, 401, "authentication required", challengeHeaders());
+  if ((req.method === "GET" || req.method === "HEAD") && !url.pathname.startsWith("/api/")) {
+    res.writeHead(302, { Location: `/login?next=${encodeURIComponent(url.pathname + url.search)}`, "Cache-Control": "no-store" });
+    return res.end();
+  }
+  return send(res, 401, { error: "Sign in first." });
 }
 const LOCKED = "too many failed logins — try again in 10 minutes";
 const asrPerIp = new Map(); // ip → open /asr sockets
@@ -93,6 +106,7 @@ function send(res, code, body, headers = {}) {
 // Upstream errors (OpenRouter, ElevenLabs, Deepgram…) can carry account or quota
 // detail. Log it here; the browser only gets a short, generic reason.
 function upstreamFail(res, e, what) {
+  if (e?.code === "daily_cap") return send(res, 503, { error: CAP_MSG }, { "Retry-After": untilMidnightUtc() });
   console.error(`  [${what}]`, e?.message || e);
   return send(res, e?.status === 429 ? 429 : 502, { error: `${what} failed` });
 }
@@ -125,7 +139,32 @@ function readBody(req, limit = 3 * 1024 * 1024) {
 
 function safeHost(req) { const h = String(req.headers.host || ""); return /^[a-z0-9.-]+(:\d+)?$/i.test(h) ? h : ""; }
 function validFrame(f) { return typeof f === "string" && f.length <= MAX_FRAME_BYTES && FRAME_RE.test(f) ? f : null; }
-function overBudget(sess) { return sess.score.ours.cost >= SESSION_BUDGET_USD; }
+const CAP_MSG = "Ava has reached today's usage limit — try again tomorrow";
+/** Why a session can't spend more (its own budget, or the daily cap across all sessions), or null. */
+function spendLimit(sess) {
+  if (!MOCK && dailyCapReached()) return CAP_MSG;
+  if (sess.score.ours.cost >= sessionBudget()) return "this session reached its spend limit — start a new call";
+  return null;
+}
+const admin = createAdmin({
+  send, readBody, LOCAL_ONLY, HOST, PORT, sessionBudget,
+  origin: (req) => `${secureReq(req) || req.headers["x-forwarded-proto"] === "https" ? "https" : "http"}://${safeHost(req) || `localhost:${PORT}`}`,
+  voice: () => ({ enabled: TTS_ENABLED, default: defaultProvider(), providers: providers() }),
+  speech: () => ({ offline: asrAvailable(), engines: availableEngines(), default: defaultEngine(), cloud: STT_ENABLED }),
+});
+
+/** Serve one HTML page from public/ with its CSP (and the login cookie, if any). */
+async function servePage(req, res, file, headers = {}) {
+  try {
+    const full = join(PUBLIC, file), html = await readFile(full), st = await stat(full);
+    return send(res, 200, html, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "Content-Security-Policy": cspFor(html, `${full}|${st.mtimeMs}`, safeHost(req)), ...authCookieHeader(req), ...headers });
+  } catch { return send(res, 404, "not found"); }
+}
+// Only same-site paths after signing in (never another host).
+const safeNext = (n) => (typeof n === "string" && /^\/(?!\/)[\w\-./?#=&%~]*$/.test(n) && !n.startsWith("/login") ? n : "/dashboard");
+const secureReq = (req) => process.env.TRUST_PROXY === "1" || !!req.socket.encrypted;
+
+const untilMidnightUtc = () => String(Math.ceil((new Date().setUTCHours(24, 0, 0, 0) - Date.now()) / 1000));
 
 async function serveStatic(req, res, pathname) {
   let p;
@@ -171,11 +210,29 @@ async function serveStatic(req, res, pathname) {
 // Pages that open a call (and everything they talk to) sit behind ACCESS_PASSWORD
 // when it's set. The landing page and its assets stay public.
 function needsAuth(pathname) {
-  return pathname.startsWith("/api/") && pathname !== "/api/health"
+  return pathname.startsWith("/api/") && pathname !== "/api/health" && !pathname.startsWith("/api/link/") // a link's id is its own key
+      && pathname !== "/api/auth/login" && pathname !== "/api/auth/mode"
     || pathname === "/app" || pathname === "/app/" || pathname === "/index.html"
-    || pathname === "/specialist" || pathname === "/specialist.html";
+    || pathname === "/specialist" || pathname === "/specialist.html"
+    || pathname === "/dashboard" || pathname === "/dashboard.html";
 }
 
+// Share-link visitors (see lib/links.mjs) may use only what a customer's call needs.
+const CUSTOMER_API = new Set(["/api/session", "/api/turn", "/api/observe", "/api/nudge", "/api/end", "/api/summary", "/api/truncate", "/api/stt", "/api/tts", "/api/handoff", "/api/bridge"]);
+/** Is this caller allowed to drive that session? Operators: any. Link visitors: calls from their own link. */
+function canUse(req, sess) {
+  return !!sess && (req.ava.operator || (!!sess.link && req.ava.links.some((l) => l.id === sess.link.id)));
+}
+function sessionFor(req, id) { const s = getSession(id); return canUse(req, s) ? s : undefined; }
+// "This computer": a loopback socket, addressed as localhost, not relayed by a proxy
+// or tunnel (cloudflared and friends also connect from 127.0.0.1).
+const isLoopback = (req) => /^(127\.|::1$|::ffff:127\.)/.test(req.socket.remoteAddress || "")
+  && /^(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i.test(String(req.headers.host || ""))
+  && !["x-forwarded-for", "forwarded", "cf-connecting-ip", "fly-client-ip", "x-real-ip"].some((h) => req.headers[h]);
+// The dashboard changes how Ava runs. Without a password it's only for this computer.
+const dashboardAllowed = (req) => req.ava.operator && (AUTH_ENABLED || LOCAL_ONLY || isLoopback(req) || !!req.ava.user?.apiKey); // an API key is a sign-in
+const DASHBOARD_LOCKED = "The dashboard is only available on this computer until you set a password. Run `npx ava-engine setup` and choose “My team or customers”.";
+
 // Aborts when the client goes away before we've answered (not after a normal finish).
 function clientGone(res) {
   const ac = new AbortController();
@@ -189,10 +246,12 @@ async function handle(req, res) {
   for (const [k, v] of Object.entries(SECURITY_HEADERS)) res.setHeader(k, v);
   let url;
   try { url = new URL(req.url, "http://x"); } catch { return send(res, 400, "bad request"); }
+  const user = currentUser(req), operator = !!user;
+  req.ava = { operator, user, links: operator ? [] : linksFromRequest(req) };
   if (needsAuth(url.pathname)) {
     // Locked-out clients get no answer about any password, right or wrong.
     if (lockedOut(req)) return send(res, 429, LOCKED, { "Retry-After": "600" });
-    if (!isAuthorized(req)) return denyAuth(req, res);
+    if (!operator && !(req.ava.links.length && CUSTOMER_API.has(url.pathname))) return denyAuth(req, res, url);
   }
   if (url.pathname.startsWith("/api/") && url.pathname !== "/api/health" && !rate.api(clientIp(req))) {
     return send(res, 429, { error: "too many requests — slow down" }, { "Retry-After": "30" });
@@ -201,6 +260,7 @@ async function handle(req, res) {
     if (req.method === "GET" && url.pathname === "/api/health") {
       return send(res, 200, {
         mock: MOCK,
+        dailyCapReached: !MOCK && dailyCapReached(),
         models: { talker: MODELS.talker, perception: MODELS.perception, planner: MODELS.planner, intent: MODELS.intent },
         labels: ROLE_LABEL,
         tts: { enabled: TTS_ENABLED, providers: providers(), default: defaultProvider() },
@@ -216,7 +276,7 @@ async function handle(req, res) {
     // End-of-call recap for the session report.
     if (req.method === "POST" && url.pathname === "/api/summary") {
       const { sessionId } = await readBody(req);
-      const sess = getSession(sessionId);
+      const sess = sessionFor(req, sessionId);
       if (!sess) return send(res, 404, { error: "unknown session" });
       try { return send(res, 200, await sessionSummary(sess)); }
       catch (e) { return upstreamFail(res, e, "summary"); }
@@ -225,7 +285,7 @@ async function handle(req, res) {
     // The user barged in — rewrite Ava's last reply to what was actually heard.
     if (req.method === "POST" && url.pathname === "/api/truncate") {
       const { sessionId, heard = "" } = await readBody(req);
-      const sess = getSession(sessionId);
+      const sess = sessionFor(req, sessionId);
       if (!sess) return send(res, 404, { error: "unknown session" });
       return send(res, 200, truncateAssistant(sess, String(heard).slice(0, 2000)));
     }
@@ -285,22 +345,36 @@ async function handle(req, res) {
     if (req.method === "POST" && url.pathname === "/api/session") {
       if (!rate.session(clientIp(req))) return send(res, 429, { error: "too many new sessions — try again in a minute" }, { "Retry-After": "60" });
       if (!hasCapacity()) return send(res, 503, { error: "Ava is at capacity right now — try again in a few minutes" }, { "Retry-After": "60" });
+      if (!MOCK && dailyCapReached()) return send(res, 503, { error: CAP_MSG }, { "Retry-After": untilMidnightUtc() });
       const body = await readBody(req);
-      const mode = body.mode === "onboarding" ? "onboarding" : "flexible";
-      const platform = typeof body.platformId === "string" ? platformById(body.platformId) : null; // knowledge in any mode
-      const s = newSession({ mode, platform });
+      // A share link fixes the product and mode; link visitors can't pick their own.
+      let link = null;
+      if (body.link != null) {
+        link = getLink(String(body.link));
+        const why = linkBlocked(link);
+        if (why) return send(res, 410, { error: why });
+        if (!operator && !req.ava.links.some((l) => l.id === link.id)) return send(res, 403, { error: "Open this call from its link." });
+      } else if (!operator) return send(res, 403, { error: "Open this call from its link." });
+      const mode = link ? link.mode : body.mode === "onboarding" ? "onboarding" : "flexible";
+      const platformId = link ? link.product : typeof body.platformId === "string" ? body.platformId : null;
+      const platform = platformId ? platformById(platformId) : null; // knowledge in any mode
+      if (link && link.product && !platform) return send(res, 410, { error: "This link's product isn't available any more. Ask whoever sent it for a new one." });
+      const s = newSession({ mode, platform, link });
       if (!s) return send(res, 503, { error: "Ava is at capacity right now — try again in a few minutes" }, { "Retry-After": "60" });
+      if (link) countLinkCall(link);
+      emitEvent("session.started", { sessionId: s.id, mode, platform: platform ? { id: platform.id, name: platform.name } : null, link: link ? { id: link.id, name: link.name } : null });
       // pre-warm the talker route so the greeting isn't a cold start
       if (!MOCK) chat({ model: MODELS.talker, role: "talker", provider: PROVIDER.talker, messages: [{ role: "user", content: "hi" }], maxTokens: 1 }).catch(() => {});
-      return send(res, 200, { sessionId: s.id, mock: MOCK, models: MODELS, mode, platform: platform ? { id: platform.id, name: platform.name, url: platform.url } : null });
+      return send(res, 200, { sessionId: s.id, mock: MOCK, models: MODELS, mode, platform: platform ? { id: platform.id, name: platform.name, url: platform.url } : null, link: link ? publicLinkView(link, platform).options : null });
     }
 
     if (req.method === "POST" && url.pathname === "/api/turn") {
       const body = await readBody(req);
       const { sessionId, frameHash = null, greet = false, voice = false, changed = false, screenActive = false } = body;
-      const sess = getSession(sessionId);
+      const sess = sessionFor(req, sessionId);
       if (!sess) return send(res, 404, { error: "unknown session" });
-      if (overBudget(sess)) return send(res, 402, { error: "this session reached its spend limit — start a new call" });
+      const limit = spendLimit(sess);
+      if (limit) return send(res, 402, { error: limit });
       const userText = String(body.userText ?? "").slice(0, MAX_USER_TEXT);
       const frame = validFrame(body.frame);
 
@@ -310,8 +384,8 @@ async function handle(req, res) {
         if (greet) await greetStream(sess, emit, !!voice);
         else await oursTurnStream(sess, userText, frame, !!screenActive, frameHash, emit, !!voice, !!changed);
       } catch (e) {
-        console.error("  [turn]", e?.message || e);
-        emit("error", { error: "Ava couldn't answer that one — try again" });
+        if (e?.code === "daily_cap") emit("error", { error: CAP_MSG });
+        else { console.error("  [turn]", e?.message || e); emit("error", { error: "Ava couldn't answer that one — try again" }); }
       }
       res.end();
       return;
@@ -319,41 +393,82 @@ async function handle(req, res) {
 
     if (req.method === "POST" && url.pathname === "/api/observe") {
       const { sessionId, frame: rawFrame, frameHash = null, stopped = false, changed = false } = await readBody(req);
-      const sess = getSession(sessionId);
+      const sess = sessionFor(req, sessionId);
       if (!sess) return send(res, 404, { error: "unknown session" });
       if (stopped) return send(res, 200, screenOff(sess)); // user stopped sharing → mark state stale now
-      if (overBudget(sess)) return send(res, 402, { error: "spend limit reached" });
+      if (spendLimit(sess)) return send(res, 402, { error: spendLimit(sess) });
       const frame = validFrame(rawFrame);
       if (!frame) return send(res, 400, { error: "no frame" });
       try { return send(res, 200, await observeUpdate(sess, frame, frameHash, !!changed)); }
       catch (e) { return upstreamFail(res, e, "screen read"); }
     }
 
-    // Specialist console page (opened at /specialist?key=<specialist key>).
-    if (req.method === "GET" && url.pathname === "/specialist") {
-      try {
-        const full = join(PUBLIC, "specialist.html"), html = await readFile(full), st = await stat(full);
-        return send(res, 200, html, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "Content-Security-Policy": cspFor(html, `${full}|${st.mtimeMs}`, safeHost(req)), ...authCookieHeader(req) });
-      }
-      catch { return send(res, 404, "not found"); }
+    // ── Signing in ──
+    if ((req.method === "GET" || req.method === "HEAD") && url.pathname === "/login") {
+      if (operator && AUTH_ENABLED) { res.writeHead(302, { Location: safeNext(url.searchParams.get("next")) }); return res.end(); }
+      return servePage(req, res, "login.html");
+    }
+    if (req.method === "GET" && url.pathname === "/api/auth/mode") return send(res, 200, { accounts: hasUsers(), password: !!process.env.ACCESS_PASSWORD, required: AUTH_ENABLED });
+    if (req.method === "POST" && url.pathname === "/api/auth/login") {
+      if (lockedOut(req) || rate.authFail.blocked(clientIp(req))) return send(res, 429, { error: LOCKED }, { "Retry-After": "600" });
+      const body = await readBody(req);
+      const r = signIn({ email: typeof body.email === "string" ? body.email.trim() : "", password: body.password }, req);
+      if (!r) { rate.authFail(clientIp(req)); return send(res, 401, { error: hasUsers() ? "That email and password don't match." : "That password isn't right." }); }
+      return send(res, 200, { ok: true, user: r.user, next: safeNext(body.next) }, { "Set-Cookie": r.setCookie });
+    }
+    if (req.method === "POST" && url.pathname === "/api/auth/logout") return send(res, 200, { ok: true }, { "Set-Cookie": logoutCookie(req) });
+    if (req.method === "GET" && url.pathname === "/api/auth/me") return send(res, 200, { user, accounts: hasUsers(), required: AUTH_ENABLED });
+
+    // ── Dashboard (operator only) ──
+    if ((req.method === "GET" || req.method === "HEAD") && (url.pathname === "/dashboard" || url.pathname === "/dashboard.html")) {
+      if (!dashboardAllowed(req)) return send(res, 403, DASHBOARD_LOCKED);
+      return servePage(req, res, "dashboard.html");
+    }
+    if (req.method === "GET" && url.pathname === "/dashboard/openrouter-callback") return await admin.finishOpenRouter(req, res, url);
+    if (url.pathname.startsWith("/api/admin/")) {
+      if (!dashboardAllowed(req)) return send(res, 403, { error: DASHBOARD_LOCKED });
+      if (req.method !== "GET" && !sameOrigin(req)) return send(res, 403, { error: "cross-site request refused" });
+      return await admin(req, res, url, req.ava.user);
+    }
+
+    // ── Share links: /c/<id> opens a customer call set up by the link ──
+    const linkPage = url.pathname.match(/^\/c\/([A-Za-z0-9_-]{22})\/?$/);
+    if (linkPage && (req.method === "GET" || req.method === "HEAD")) {
+      const l = getLink(linkPage[1]);
+      const live = l && l.enabled && !(l.expiresAt && Date.parse(l.expiresAt) <= Date.now());
+      return servePage(req, res, "index.html", live ? { "Set-Cookie": linkCookieHeader(l.id, secureReq(req)) } : {});
+    }
+    const linkApi = url.pathname.match(/^\/api\/link\/([A-Za-z0-9_-]{1,64})$/);
+    if (linkApi && req.method === "GET") {
+      const l = getLink(linkApi[1]);
+      const why = linkBlocked(l);
+      if (!l) return send(res, 404, { error: why });
+      const p = l.product ? platformById(l.product) : null;
+      if (l.product && !p) return send(res, 410, { error: "This link's product isn't available any more. Ask whoever sent it for a new one." });
+      return send(res, why ? 410 : 200, { ...publicLinkView(l, p), ...(why ? { error: why } : {}) });
     }
 
+    // Specialist console page (opened at /specialist?key=<specialist key>).
+    if (req.method === "GET" && url.pathname === "/specialist") return servePage(req, res, "specialist.html");
+
     // Live bridge between the user's call and a human specialist. The user is
     // identified by sessionId; the specialist only ever holds the specialist key
     // minted when the user asked for a person (revoked when the handoff ends).
     if (req.method === "GET" && url.pathname === "/api/bridge") {
       const key = url.searchParams.get("key");
-      const sess = key ? getSessionBySpecialistKey(key) : getSession(url.searchParams.get("sessionId"));
+      if (key && !operator) return send(res, 401, { error: "specialists sign in with the team password" });
+      const sess = key ? getSessionBySpecialistKey(key) : sessionFor(req, url.searchParams.get("sessionId"));
       if (!sess) return send(res, 404, { error: "unknown session" });
       return send(res, 200, bridgePoll(sess, Number(url.searchParams.get("since")) || 0));
     }
     if (req.method === "POST" && url.pathname === "/api/bridge") {
       const { sessionId, key, action = "say", text = "" } = await readBody(req);
       if (action === "usersay") {
-        const sess = getSession(sessionId);
+        const sess = sessionFor(req, sessionId);
         if (!sess) return send(res, 404, { error: "unknown session" });
         return send(res, 200, userSayToBridge(sess, String(text).slice(0, MAX_USER_TEXT)));
       }
+      if (!operator) return send(res, 401, { error: "specialists sign in with the team password" });
       const sess = getSessionBySpecialistKey(key);
       if (!sess) return send(res, 404, { error: "unknown or expired link" });
       if (action === "join") { const r = specialistJoin(sess); return r ? send(res, 200, r) : send(res, 409, { error: "no handoff requested" }); }
@@ -371,24 +486,25 @@ async function handle(req, res) {
     // Human handoff — request a real person, poll the connect state.
     if (req.method === "POST" && url.pathname === "/api/handoff") {
       const { sessionId, action = "request" } = await readBody(req);
-      const sess = getSession(sessionId);
+      const sess = sessionFor(req, sessionId);
       if (!sess) return send(res, 404, { error: "unknown session" });
       if (action === "cancel") return send(res, 200, cancelHandoff(sess));
+      if (sess.link && getLink(sess.link.id)?.handoff === false) return send(res, 403, { error: "Talking to a person isn't available on this link." });
       if (action === "status") return send(res, 200, handoffStatus(sess));
       return send(res, 200, requestHandoff(sess));
     }
 
     if (req.method === "POST" && url.pathname === "/api/nudge") {
       const { sessionId } = await readBody(req);
-      const sess = getSession(sessionId);
+      const sess = sessionFor(req, sessionId);
       if (!sess) return send(res, 404, { error: "unknown session" });
-      if (overBudget(sess)) return send(res, 402, { error: "spend limit reached" });
+      if (spendLimit(sess)) return send(res, 402, { error: spendLimit(sess) });
       try { return send(res, 200, await proactiveNudge(sess)); }
       catch (e) { return upstreamFail(res, e, "nudge"); }
     }
 
     if (req.method === "GET" && url.pathname === "/api/scoreboard") {
-      const sess = getSession(url.searchParams.get("sessionId"));
+      const sess = sessionFor(req, url.searchParams.get("sessionId"));
       if (!sess) return send(res, 404, { error: "unknown session" });
       return send(res, 200, { ours: scoreView(sess.score.ours) });
     }
@@ -421,7 +537,9 @@ server.on("upgrade", (req, socket, head) => {
   const reject = (code, msg) => { try { socket.write(`HTTP/1.1 ${code} ${msg}\r\nConnection: close\r\n\r\n`); } catch {} socket.destroy(); };
   if (!sameOrigin(req)) return reject(403, "Forbidden");
   if (lockedOut(req)) return reject(429, "Too Many Requests");
-  if (!isAuthorized(req)) { if (triedPassword(req)) rate.authFail(clientIp(req)); return reject(401, "Unauthorized"); }
+  const operator = isAuthorized(req), links = operator ? [] : linksFromRequest(req);
+  if (!operator && !links.length) { if (triedPassword(req)) rate.authFail(clientIp(req)); return reject(401, "Unauthorized"); }
+  req.ava = { operator, user: currentUser(req), links };
   if (path === "/asr") {
     const ip = clientIp(req);
     if (asrOpen >= MAX_ASR_TOTAL || (asrPerIp.get(ip) || 0) >= MAX_ASR_PER_IP) return reject(503, "Service Unavailable");
@@ -435,7 +553,8 @@ rtcWss.on("connection", (ws, req) => {
   const role = u.searchParams.get("role") === "specialist" ? "specialist" : "user";
   const other = role === "user" ? "specialist" : "user";
   // The user proves the call with its session id, the specialist with the handoff key.
-  const sess = role === "specialist" ? getSessionBySpecialistKey(u.searchParams.get("key")) : getSession(u.searchParams.get("session"));
+  // Specialists are the operator's team; a share-link visitor can only be the customer.
+  const sess = role === "specialist" ? (req.ava.operator ? getSessionBySpecialistKey(u.searchParams.get("key")) : null) : sessionFor(req, u.searchParams.get("session"));
   if (!sess) { try { ws.close(4404, "unknown session"); } catch {} return; }
   const session = sess.id;
   let room = rtcRooms.get(session);
@@ -477,9 +596,6 @@ wss.on("connection", (ws, req) => {
   ws.on("error", () => {});
 });
 
-// HOST=127.0.0.1 keeps Ava private to this computer (the CLI's "just me" setup).
-const HOST = process.env.HOST || undefined;
-const LOCAL_ONLY = HOST === "127.0.0.1" || HOST === "localhost" || HOST === "::1";
 
 server.on("error", (e) => {
   if (e.code === "EADDRINUSE") console.error(`\n  ✗ Port ${PORT} is already in use. Stop whatever is using it, or pick another port (PORT=5191, or \`ava-engine start --port 5191\`).\n`);
@@ -490,12 +606,16 @@ server.on("error", (e) => {
 
 server.listen(PORT, HOST, () => {
   console.log(`\n  Ava — screen-aware voice agent`);
-  console.log(`  → http://localhost:${PORT}/app`);
+  console.log(`  → dashboard  http://localhost:${PORT}/dashboard`);
+  console.log(`  → test call  http://localhost:${PORT}/app`);
   console.log(`  mode: ${MOCK ? "MOCK (no OPENROUTER_API_KEY set — synthetic replies)" : "LIVE (OpenRouter)"}`);
   if (!MOCK) console.log(`  models: talker=${MODELS.talker}  perception=${MODELS.perception}  planner=${MODELS.planner}  intent=${MODELS.intent}`);
+  if (!MOCK) console.log(DAILY_BUDGET_USD ? `  daily cap: $${DAILY_BUDGET_USD} (spent today: $${spentToday().toFixed(2)})` : "  daily cap: none (set DAILY_BUDGET_USD to limit spend across all calls)");
+  if (CUSTOM_PLAYBOOKS.count) console.log(`  playbooks: ${CUSTOM_PLAYBOOKS.count} from ${CUSTOM_PLAYBOOKS.dir}`);
+  if (WEBHOOKS_ENABLED) console.log("  webhooks: on");
   if (LOCAL_ONLY) console.log("  access: this computer only");
   else if (!AUTH_ENABLED) console.log("  access: OPEN — anyone who can reach this server can spend your API credit. Set ACCESS_PASSWORD before exposing it.");
-  else console.log("  access: password protected");
+  else console.log(hasUsers() ? "  access: team accounts (sign in at /login)" : "  access: password protected");
   console.log("");
   warmKokoro(); // preload the offline voice so the first reply is fast
   warmAsr();    // preload the offline ear so the first utterance is fast