@oratis/lisa 0.12.0 → 0.14.0

package/dist/web/server.js

@@ -33,8 +33,16 @@ import { signalAgentTool } from "../tools/signal_agent.js";
 import { managedRegistry } from "../agents/managed.js";
 import { ptyRegistry, ptyEnabled, normalizeAgentKind } from "../agents/pty.js";
 import { liveClaudeSessionIds } from "../integrations/claude-code/liveness.js";
+import { sweepAll, pollNewMail } from "../mail/service.js";
+import { pickImportant, formatAlert, alertLevel, pollMinutes } from "../mail/alerts.js";
+import { latestDigest } from "../mail/store.js";
+import { formatDigestText } from "../mail/digest.js";
+import { isDigestDue, digestHour } from "../mail/scheduler.js";
+import { loadAccounts, addAccount, removeAccount, setAccountEnabled } from "../mail/accounts.js";
+import { inferHost } from "../mail/hosts.js";
 import { listRecentDispatches, isAlive, toDispatchView, readDispatchOutput } from "../integrations/dispatch-ledger.js";
 import { loadControlPolicy, saveControlPolicy } from "../control/policy.js";
+import { loadAutonomyState, saveAutonomyState } from "../autonomy/state.js";
 import { mintDevice, verifyDeviceToken, touchDevice, listDevices, revokeDevice } from "./devices.js";
 import { PushBridge, listPush, registerPush, unregisterPush, setPushPrefs, registerLiveActivity, unregisterLiveActivity } from "./push.js";
 import { SenseService } from "../sense/service.js";
@@ -44,6 +52,10 @@ import { appendSenseEvent, readSenseEvents } from "../sense/log.js";
 import { loadScreenAdvisorConfig, saveScreenAdvisorConfig, normalizeConfig, analyzeScreenshot, } from "../screen_advisor/engine.js";
 import os from "node:os";
 import { LISA_HOME } from "../paths.js";
+import { isCloud, editionInfo } from "../edition.js";
+import { verifyAppleIdentityToken, fetchAppleKeys, appleSignInConfig, subAllowed, AppleAuthError, } from "./cloudAuth.js";
+import { detectLanHost, buildPairUrl } from "./pairing.js";
+import { qrSvg } from "./qr-svg.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ASSETS_DIR = path.join(__dirname, "assets");
 /** True for loopback peer/bind addresses (v4, v6, and v4-mapped-v6 forms). */
@@ -62,8 +74,8 @@ function timingSafeEqualStr(a, b) {
  * is authorized iff it's loopback (the local user) OR it presents the correct
  * LISA_WEB_TOKEN. No token configured ⇒ no non-loopback request can pass. Pure.
  */
-export function isRequestAuthorized(remoteAddr, webToken, presented) {
-    if (isLoopbackAddress(remoteAddr))
+export function isRequestAuthorized(remoteAddr, webToken, presented, trustLoopback = true) {
+    if (trustLoopback && isLoopbackAddress(remoteAddr))
         return true;
     return !!webToken && !!presented && timingSafeEqualStr(presented, webToken);
 }
@@ -275,6 +287,92 @@ export async function startWebServer(opts) {
     }, ADVISE_INTERVAL_MS);
     if (adviseTimer.unref)
         adviseTimer.unref();
+    // ── Mail digest (daily) ─────────────────────────────────────────────
+    // Once past the target hour, if not already done today, sweep all mailboxes,
+    // build + push the classified digest. Inert unless `mail` consent is granted
+    // and at least one account is connected.
+    let mailSweepRunning = false;
+    const afterMailDigest = (digest) => {
+        broadcast({
+            type: "mail_digest_update",
+            date: digest.date,
+            total: digest.total,
+            needsYou: digest.needsYou.length,
+            at: new Date().toISOString(),
+        });
+        pushBridge.onMailDigest(formatDigestText(digest));
+    };
+    const runMailDigest = async (force) => {
+        if (mailSweepRunning || !isGranted("mail"))
+            return null;
+        if (loadAccounts().filter((a) => a.enabled).length === 0)
+            return null;
+        if (!force && !isDigestDue(latestDigest()?.date ?? null, new Date(), digestHour()))
+            return null;
+        mailSweepRunning = true;
+        try {
+            const { digest } = await sweepAll();
+            afterMailDigest(digest);
+            // Post the digest into the chat too (the "here's your mail" moment), in
+            // addition to the push — but only on the scheduled daily run, not manual.
+            if (!force && digest.total > 0) {
+                broadcast({ type: "idle_message", text: formatDigestText(digest), at: new Date().toISOString(), source: "mail" });
+            }
+            console.error(`[mail] digest ${digest.date}: ${digest.total} mail · ${digest.needsYou.length} need-you`);
+            return digest;
+        }
+        catch (err) {
+            console.error(`[mail] digest sweep failed: ${err.message}`);
+            return null;
+        }
+        finally {
+            mailSweepRunning = false;
+        }
+    };
+    const mailTimer = setInterval(() => void runMailDigest(false), 30 * 60_000);
+    if (mailTimer.unref)
+        mailTimer.unref();
+    // Catch a restart that happens after the target hour (don't wait 30m).
+    const mailKick = setTimeout(() => void runMailDigest(false), 20_000);
+    if (mailKick.unref)
+        mailKick.unref();
+    // ── Important-mail alerts (intraday) ────────────────────────────────
+    // Every LISA_MAIL_POLL_MINUTES (default 30; 0 disables), incrementally read
+    // NEW mail; for items at/above the alert level, fire a high-priority push +
+    // a proactive chat message. Inert without consent + an account.
+    const mailPollMin = pollMinutes();
+    if (mailPollMin > 0) {
+        let mailPollRunning = false;
+        const mailPoll = setInterval(() => {
+            void (async () => {
+                if (mailPollRunning || !isGranted("mail"))
+                    return;
+                if (loadAccounts().filter((a) => a.enabled).length === 0)
+                    return;
+                mailPollRunning = true;
+                try {
+                    const important = pickImportant(await pollNewMail(), alertLevel());
+                    if (important.length === 0)
+                        return;
+                    for (const item of important.slice(0, 3)) {
+                        const alert = formatAlert(item);
+                        pushBridge.onMailImportant({ title: alert.title, body: alert.body, tag: alert.tag });
+                        broadcast({ type: "idle_message", text: alert.chat, at: new Date().toISOString(), source: "mail" });
+                    }
+                    broadcast({ type: "mail_digest_update", at: new Date().toISOString() });
+                    console.error(`[mail] ${important.length} important new mail (alerted ${Math.min(3, important.length)})`);
+                }
+                catch (err) {
+                    console.error(`[mail] poll failed: ${err.message}`);
+                }
+                finally {
+                    mailPollRunning = false;
+                }
+            })();
+        }, mailPollMin * 60_000);
+        if (mailPoll.unref)
+            mailPoll.unref();
+    }
     // ── Screen advisor (opt-in): periodic screen-grounded next-step ─────
     // When enabled, every N minutes capture a full-screen shot, ask the model
     // for the single best next coding step, and push it to the island as a
@@ -420,10 +518,67 @@ export async function startWebServer(opts) {
         // full-tool agent and /api/vision/capture grabs the screen, so an
         // unauthenticated non-loopback request is a remote-code-execution hole.
         const remoteAddr = req.socket.remoteAddress ?? "";
-        if (!isLoopbackAddress(remoteAddr)) {
+        // In the hosted cloud edition there is no trusted local user — the gate runs
+        // for EVERY request and loopback is not a free pass (the container must never
+        // trust its own/proxy loopback). Mac edition: loopback = the local owner.
+        const cloud = isCloud();
+        // ── Sign in with Apple (cloud edition) ───────────────────────────────────
+        // Public on purpose: this endpoint *mints* access, so it runs BEFORE the
+        // token gate. The iOS app sends the Apple identity token; we verify it
+        // against Apple's keys and hand back the cloud session token (= the shared
+        // LISA_WEB_TOKEN — single-tenant, matching the M0/C2 demo). Default-OFF:
+        // disabled unless LISA_CLOUD_APPLE_SIGNIN is set, so we never leak the token.
+        // See src/web/cloudAuth.ts + docs/PLAN_CLOUD_v1.0.md.
+        if (req.method === "POST" && url === "/api/auth/apple") {
+            const cfg = appleSignInConfig();
+            if (!cloud || !cfg.enabled) {
+                res.writeHead(404, { "content-type": "text/plain" });
+                res.end("apple sign-in not available");
+                return;
+            }
+            if (!webToken) {
+                res.writeHead(503, { "content-type": "text/plain" });
+                res.end("cloud sign-in misconfigured (no session token)");
+                return;
+            }
+            let abBody = "";
+            for await (const chunk of req)
+                abBody += chunk.toString("utf8");
+            let payload = {};
+            try {
+                payload = abBody ? JSON.parse(abBody) : {};
+            }
+            catch { /* tolerate */ }
+            const idToken = typeof payload.identityToken === "string" ? payload.identityToken : "";
+            if (!idToken) {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("identityToken required");
+                return;
+            }
+            try {
+                const id = await verifyAppleIdentityToken(idToken, {
+                    audience: cfg.audience,
+                    fetchKeys: fetchAppleKeys,
+                });
+                if (!subAllowed(id.sub, cfg)) {
+                    res.writeHead(403, { "content-type": "text/plain" });
+                    res.end("this Apple ID is not allowed on this LISA Cloud instance");
+                    return;
+                }
+                res.writeHead(200, { "content-type": "application/json" });
+                res.end(JSON.stringify({ ok: true, token: webToken }));
+            }
+            catch (e) {
+                const msg = e instanceof AppleAuthError ? e.message : "verification failed";
+                res.writeHead(401, { "content-type": "text/plain" });
+                res.end(`apple sign-in rejected: ${msg}`);
+            }
+            return;
+        }
+        if (cloud || !isLoopbackAddress(remoteAddr)) {
             const presented = webToken ? presentedToken(req, url) : null;
             // Authorized by the global LISA_WEB_TOKEN OR a non-revoked per-device token.
-            let authed = isRequestAuthorized(remoteAddr, webToken, presented);
+            let authed = isRequestAuthorized(remoteAddr, webToken, presented, !cloud);
             if (!authed && presented) {
                 const device = verifyDeviceToken(presented);
                 if (device) {
@@ -465,14 +620,24 @@ export async function startWebServer(opts) {
             return true;
         };
         if (req.method === "GET" && (url === "/" || url.startsWith("/?"))) {
-            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            // no-store: never cache the shell, or a WKWebView / browser keeps rendering
+            // an old GUI after `lisa` is updated (the shell carries the current markup +
+            // asset references). Fixes the "removed element still shows" stale-cache bug.
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
             res.end(MAIN_HTML);
             return;
         }
+        // Edition + capability descriptor — the client hides Mac-only surfaces
+        // (PTY/adopt, local dispatch, Sense, agent control) in the cloud edition.
+        if (req.method === "GET" && url === "/api/edition") {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify(editionInfo()));
+            return;
+        }
         // Island widget — designed to be opened in a tiny browser window
         // (Arc, Vivaldi PWA, Safari split). See docs/MAC_ISLAND_PLAN.md.
         if (req.method === "GET" && (url === "/island" || url.startsWith("/island?"))) {
-            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
             res.end(ISLAND_HTML);
             return;
         }
@@ -778,8 +943,21 @@ export async function startWebServer(opts) {
             const name = typeof payload.name === "string" ? payload.name : "device";
             const platform = typeof payload.platform === "string" ? payload.platform : "ios";
             const { id, token, device } = mintDevice(name, platform);
+            // Detect a phone-reachable LAN host server-side so every client (CLI, Mac
+            // app, web UI) can show consistent, copyable pairing details — the browser
+            // can't discover the Mac's LAN IP on its own. A caller-supplied host wins.
+            const host = typeof payload.host === "string" && payload.host.trim()
+                ? payload.host.trim()
+                : detectLanHost();
+            const url = host ? buildPairUrl(host, opts.port, token, name) : undefined;
+            // The interface the server is actually bound to. If it's loopback-only, a
+            // phone can't reach it however good the QR is — the client warns on this.
+            const boundHost = opts.host ?? "127.0.0.1";
+            // A scannable QR of the pairing link, for the web "Pair phone" modal (the
+            // browser equivalent of the CLI's terminal QR). Only when we have a url.
+            const qr = url ? qrSvg(url) : undefined;
             res.writeHead(200, { "content-type": "application/json" });
-            res.end(JSON.stringify({ ok: true, id, token, port: opts.port, device }));
+            res.end(JSON.stringify({ ok: true, id, token, port: opts.port, host, url, boundHost, qrSvg: qr, device }));
             return;
         }
         if (req.method === "GET" && url === "/api/devices") {
@@ -893,6 +1071,92 @@ export async function startWebServer(opts) {
             res.end(JSON.stringify(sub ? { ok: true, subscription: sub } : { ok: false }));
             return;
         }
+        // ── Mail module (read-only): accounts, connect, sweep, digest ───────
+        if (req.method === "GET" && url === "/api/mail/accounts") {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ accounts: loadAccounts(), consent: isGranted("mail") }));
+            return;
+        }
+        if (req.method === "GET" && url === "/api/mail/digest") {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ digest: latestDigest() }));
+            return;
+        }
+        if (req.method === "POST" && url === "/api/mail/connect") {
+            let mBody = "";
+            for await (const chunk of req)
+                mBody += chunk.toString("utf8");
+            let p;
+            try {
+                p = JSON.parse(mBody || "{}");
+            }
+            catch {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("bad json");
+                return;
+            }
+            const email = typeof p.email === "string" ? p.email.trim() : "";
+            const password = typeof p.password === "string" ? p.password : "";
+            if (!email.includes("@") || !password) {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("email + password required");
+                return;
+            }
+            const host = typeof p.host === "string" && p.host ? p.host : inferHost(email);
+            if (!host) {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("couldn't infer IMAP host — pass host");
+                return;
+            }
+            const account = addAccount({
+                provider: "imap",
+                email,
+                host,
+                port: typeof p.port === "number" ? p.port : 993,
+                label: typeof p.label === "string" ? p.label : undefined,
+            }, { password });
+            grant("mail"); // connecting a mailbox is the consent act
+            broadcast({ type: "mail_accounts_update", at: new Date().toISOString() });
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, account }));
+            return;
+        }
+        if (req.method === "POST" && url.startsWith("/api/mail/accounts/")) {
+            const rest = url.slice("/api/mail/accounts/".length);
+            const slash = rest.indexOf("/");
+            const id = decodeURIComponent(slash >= 0 ? rest.slice(0, slash) : rest);
+            const action = slash >= 0 ? rest.slice(slash + 1) : "";
+            let ok = false;
+            if (action === "remove")
+                ok = removeAccount(id);
+            else if (action === "enable")
+                ok = setAccountEnabled(id, true);
+            else if (action === "disable")
+                ok = setAccountEnabled(id, false);
+            else {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("action must be remove|enable|disable");
+                return;
+            }
+            if (ok)
+                broadcast({ type: "mail_accounts_update", at: new Date().toISOString() });
+            res.writeHead(ok ? 200 : 404, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok }));
+            return;
+        }
+        if (req.method === "POST" && url === "/api/mail/sweep") {
+            if (!isGranted("mail")) {
+                res.writeHead(409, { "content-type": "text/plain" });
+                res.end("mail consent not granted");
+                return;
+            }
+            const swept = await sweepAll();
+            if (!swept.blocked)
+                afterMailDigest(swept.digest);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: !swept.blocked, digest: swept.digest, newItems: swept.newItems.length }));
+            return;
+        }
         // Remote-control policy: GET (any authed caller) reports it; POST sets it,
         // but only from localhost (the Mac owner) — like the API-key save.
         if (req.method === "GET" && url === "/api/control/policy") {
@@ -929,6 +1193,40 @@ export async function startWebServer(opts) {
             }
             return;
         }
+        // Autonomy on/off — the "Proactive mode" master switch surfaced in the web
+        // GUI + iOS as the Proactive toggle. GET reports it (any authed caller);
+        // POST sets it. Unlike the control policy (loopback-only), this is allowed
+        // from any authed device — letting Lisa rest is low-risk, and pausing her
+        // from the phone is a primary use case. The token gate (above) still applies.
+        if (req.method === "GET" && url === "/api/autonomy/state") {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify(loadAutonomyState()));
+            return;
+        }
+        if (req.method === "POST" && url === "/api/autonomy/state") {
+            let asBody = "";
+            for await (const chunk of req)
+                asBody += chunk.toString("utf8");
+            let payload;
+            try {
+                payload = JSON.parse(asBody || "{}");
+            }
+            catch {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("bad json");
+                return;
+            }
+            try {
+                const saved = saveAutonomyState({ ...loadAutonomyState(), ...payload });
+                res.writeHead(200, { "content-type": "application/json" });
+                res.end(JSON.stringify(saved));
+            }
+            catch (err) {
+                res.writeHead(500, { "content-type": "text/plain" });
+                res.end(err.message);
+            }
+            return;
+        }
         // Structured view of the agents LISA dispatched fire-and-forget (the ledger).
         // Complements /api/agent/signal's action:"list" (which returns prose): this is
         // JSON for clients (the iOS roster). Structural only — never the captured log.
@@ -1678,12 +1976,34 @@ self.addEventListener('fetch', (event) => {
                 "cache-control": "no-cache",
                 connection: "keep-alive",
             });
-            const send = (event) => res.write(`data: ${JSON.stringify(event)}\n\n`);
+            // Guard writes: once the client disconnects the socket is gone, and a bare
+            // res.write would throw "write after end" from inside the agent loop.
+            const send = (event) => {
+                if (res.writableEnded || res.destroyed)
+                    return;
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            };
+            // Per-turn cancellation: if the client disconnects (taps Stop / closes the
+            // app), abort THIS turn's agent so it stops burning tokens and the next
+            // queued turn isn't stuck behind an abandoned run.
+            const turnAbort = new AbortController();
+            req.on("close", () => turnAbort.abort());
             const onMood = (slug) => send({ type: "mood", slug });
             moodBus.on("mood", onMood);
             // Send the current mood immediately so a fresh tab knows where to start.
             send({ type: "mood", slug: moodBus.current() });
             const runTurn = async () => {
+                // runAgent emits an error event for a failed turn AND rethrows; without
+                // this guard the catch below would send a second, identical error event
+                // (the client used to render the same error twice).
+                let errorSent = false;
+                // Track whether the turn produced anything visible. A model call can
+                // return a clean, successful turn with zero text and zero tools (e.g. a
+                // provider hiccup returns an empty completion). Without a signal the
+                // client can only guess ("(no response)"); we emit an explicit `empty`
+                // event so it can offer a retry instead of a dead end.
+                let anyText = false;
+                let anyTool = false;
                 try {
                     // Use the freshest cached prompt for this chat. If soul / skills /
                     // memory changed since the previous chat, rebuildPrompt() picks it up.
@@ -1694,7 +2014,8 @@ self.addEventListener('fetch', (event) => {
                         tools: opts.tools,
                         toolCtx: {
                             cwd: process.cwd(),
-                            signal: abort.signal,
+                            // Abort on server shutdown OR this client disconnecting (Stop).
+                            signal: AbortSignal.any([abort.signal, turnAbort.signal]),
                             log: () => { },
                         },
                         history,
@@ -1703,8 +2024,12 @@ self.addEventListener('fetch', (event) => {
                         model: opts.model,
                         thinking: opts.thinking,
                         onEvent: (ev) => {
-                            if (ev.type === "text_delta" && ev.text)
+                            if (ev.type === "text_delta" && ev.text) {
+                                anyText = true;
                                 send({ type: "text", text: ev.text });
+                            }
+                            if (ev.type === "tool_call_start")
+                                anyTool = true;
                             if (ev.type === "tool_call_start")
                                 send({
                                     type: "tool_start",
@@ -1722,8 +2047,10 @@ self.addEventListener('fetch', (event) => {
                                 });
                             if (ev.type === "system_prompt_rebuilt")
                                 send({ type: "soul_reload", message: ev.message ?? "" });
-                            if (ev.type === "error")
+                            if (ev.type === "error") {
+                                errorSent = true;
                                 send({ type: "error", message: ev.message ?? "" });
+                            }
                         },
                         // Same plugin hook wiring as the CLI turn — PreToolUse can block,
                         // PostToolUse can rewrite. (Was CLI-only; web tool calls bypassed
@@ -1754,10 +2081,13 @@ self.addEventListener('fetch', (event) => {
                     });
                     history.length = 0;
                     history.push(...result.history);
+                    if (!anyText && !anyTool && !errorSent)
+                        send({ type: "empty" });
                     send({ type: "done" });
                 }
                 catch (err) {
-                    send({ type: "error", message: err.message });
+                    if (!errorSent)
+                        send({ type: "error", message: err.message });
                 }
                 finally {
                     moodBus.off("mood", onMood);