@lampdotdev/lamp 0.35.0 → 0.36.2-nightly.16

package/cli/calls.mjs

@@ -24,11 +24,28 @@ import { fileURLToPath } from "node:url";
 import { Away, OffNetwork, Refused, Rejected, Runner, StillWorking, answersOn, bonjour, pinsAt, searchNetwork, send, ssdp } from "./devices.mjs";
 import { adbCommand, connectTo, deviceListing, deviceProperties, displaySizeOf, dumpIn, installApk, installTools, launchApp, makeEmulator, pairWith, processIn, processOf,
   rowsOf, saveState, screenItems, screenshotOf, tellApp, toolsThere, useLamps } from "./android.mjs";
-import { Unreachable, ideasOf, latestOf, publishLink, removeFile, removeIdea, removeLink, sendFile } from "./link.mjs";
+import { accountFor, keepAccount } from "./share.mjs";
+import { Unreachable, accountName, askAccount, ideasOf, latestOf, pageUp, makerOf, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile } from "./link.mjs";
 import { defaultRoute, homeNetwork, neighbours, samsungAt, subnetOn, tvsIn } from "./network.mjs";
 import { PUBLISHER, identityName, keptSigner, namesOf, packageOf, versionAfter } from "./msix.mjs";
 import { tile } from "./png.mjs";
 import { Problem } from "./state.mjs";
+import { allowed as pagesAllowed, forgetPage, serveLocalAI } from "./local-ai.mjs";
+import { EngineTrouble, complete } from "./ai.mjs";
+import { OpenRouterTrouble, chat as openRouterChat, decide as openRouterDecide, image as openRouterImage, text as openRouterText } from "./openrouter.mjs";
+
+/** OpenRouter's answer, or what kept it from one, as Lamp's app reads it. */
+async function openRouter(asking) {
+  try { return await asking(); } catch (error) {
+    if (!(error instanceof OpenRouterTrouble)) throw error;
+    return { trouble: { kind: error.kind, message: error.message, status: error.status, reply: error.reply, cost: error.cost } };
+  }
+}
+import { Refused as StepRefused, chatBody, decidePrompt, planPrompt, planSchema, readDecision, readMessage, readPlan, readStep } from "./app-ai.mjs";
+
+// Pages shared on lamp.dev asking for their AI, answered by Lamp's app (`sharedPages`): what each is waiting on from it.
+const sharedPagesWaiting = new Map();
+let sharedPagesAsked = 0;
 
 /** A number of seconds a call was given, within what it may take. */
 const seconds = (given, standard, most = 10) => Math.min(Math.max(Number(given) > 0 ? Number(given) : standard, 0.5), most);
@@ -153,7 +170,43 @@ export const CALLS = {
    */
   async linkPublish(given) {
     const earlier = given.earlier && typeof given.earlier.id === "string" ? given.earlier : null;
-    return publishLink({ site: siteOf(given), body: given.body ?? {}, earlier });
+    // Sent with the maker's account key, the one `lamp account` keeps, unless the call names another: the link goes
+    // under their username once it's confirmed.
+    const site = siteOf(given);
+    return publishLink({ site, body: given.body ?? {}, earlier, account: typeof given.account === "string" ? given.account : accountFor(site)?.key });
+  },
+
+  /**
+   * The maker's account on `site`, as lamp keeps it: `account` null with none, else its username, the address that
+   * confirms it, and `confirmed` (null when the site can't be asked just now).
+   */
+  async account(given) {
+    const site = siteOf(given);
+    const kept = accountFor(site);
+    if (!kept) return { account: null };
+    let name;
+    try { name = await accountName({ site, key: kept.key }); } catch { return { account: { username: kept.username, email: kept.email ?? null, confirmed: null } }; }
+    // An address signing in to its account learns the username only once it's confirmed.
+    if (name && name !== kept.username) keepAccount(site, { ...kept, username: name });
+    return { account: { username: name ?? kept.username, email: kept.email ?? null, confirmed: !!name } };
+  },
+
+  /**
+   * Asks `site` for an account (`username`, `email`), or with an address alone, to sign in to the one it has; the key is
+   * kept as `lamp account` keeps it, and works once the email's link is opened. Its username and whether the email went.
+   */
+  async accountAsk(given) {
+    const site = siteOf(given);
+    const email = text(given, "email");
+    const asked = await askAccount({ site, username: typeof given.username === "string" && given.username ? given.username : undefined, email });
+    keepAccount(site, { username: asked.username, key: asked.key, email });
+    return { username: asked.username ?? null, existing: !!asked.existing, sent: asked.sent !== false };
+  },
+
+  /** Forgets the maker's account on `site` here (the one waiting for a mistyped address, say). */
+  async accountForget(given) {
+    keepAccount(siteOf(given), undefined);
+    return {};
   },
 
   /** What a followed link has now, asked with nothing of the person's; `latest` null when it can't be asked or is gone. */
@@ -163,8 +216,10 @@ export const CALLS = {
 
   /** The link's file (or with `page`, its playable page), from a file of Lamp's at `file`, sent in parts. */
   async linkUpload(given, how = {}) {
-    return { version: await sendFile({ site: siteOf(given), link: linkOf(given), bytes: readFileSync(text(given, "file")), page: given.page === true,
-      said: (line) => how.event?.({ said: line }) }) };
+    const said = (line) => how.event?.({ said: line });
+    const version = await sendFile({ site: siteOf(given), link: linkOf(given), bytes: readFileSync(text(given, "file")), page: given.page === true, said });
+    if (given.page === true) await pageUp({ site: siteOf(given), id: linkOf(given).id, version, said });
+    return { version };
   },
 
   /** Takes the link's file away (with `page`, only its page). */
@@ -173,14 +228,26 @@ export const CALLS = {
     return {};
   },
 
-  /** The ideas sent to the link that are still open. */
+  /** The ideas sent to the link that are still open or answered since; with `earlier`, those seen to. */
   async linkIdeas(given) {
-    return { ideas: await ideasOf({ site: siteOf(given), link: linkOf(given) }) };
+    return { ideas: await ideasOf({ site: siteOf(given), link: linkOf(given), earlier: given.earlier === true }) };
   },
 
-  /** Lets an idea go; with `built` it's in, and the site writes to whoever asked to hear. */
+  /** Lets an idea go; with `built` it's in, and the site writes to whoever asked to hear, with `note` if there is one. */
   async linkRemoveIdea(given) {
-    return removeIdea({ site: siteOf(given), link: linkOf(given), n: Number(given.n), built: given.built === true });
+    const note = typeof given.note === "string" && given.note.trim() ? given.note.trim() : undefined;
+    return removeIdea({ site: siteOf(given), link: linkOf(given), n: Number(given.n), built: given.built === true, note });
+  },
+
+  /** Says something more about an idea, emailed to its sender if they gave an address; without `note`, it's seen to. */
+  async linkReplyIdea(given) {
+    const note = typeof given.note === "string" && given.note.trim() ? given.note.trim() : undefined;
+    return replyIdea({ site: siteOf(given), link: linkOf(given), n: Number(given.n), note });
+  },
+
+  /** The maker's own address for the link's ideas; with `email` (a string, "" for none), given, to be confirmed. */
+  async linkMaker(given) {
+    return makerOf({ site: siteOf(given), link: linkOf(given), ...(typeof given.email === "string" ? { email: given.email.trim() } : {}) });
   },
 
   /** Takes the link down. */
@@ -299,6 +366,135 @@ export const CALLS = {
     return { table: await neighbours(), gateway: route?.gateway ?? null, subnet: route ? subnetOn(route.interface) : null };
   },
 
+  /**
+   * A text answer from OpenRouter for an app's AI (`AppAI.viaOpenRouter`), with the person's `key`, given on the input
+   * like everything else and kept nowhere: `prompt`, `images`, `system`, `model`, `json`, `schema`. `{text, cost}`, or
+   * `{trouble: {kind, message, status, reply, cost}}`.
+   */
+  async openRouterText(given, { stopped } = {}) {
+    return openRouter(() => openRouterText({ key: text(given, "key"), prompt: text(given, "prompt"), images: given.images, system: given.system ?? "",
+      model: text(given, "model"), json: given.json === true, schema: given.schema ?? undefined, seconds: seconds(given.seconds, 120, 600), signal: stopped }));
+  },
+
+  /** One chat completion from OpenRouter, its request as `body` (`actAsk`'s): `{message, cost}`, or `{trouble}`. */
+  async openRouterChat(given, { stopped } = {}) {
+    return openRouter(() => openRouterChat({ key: text(given, "key"), body: given.body ?? {}, seconds: seconds(given.seconds, 60, 600), signal: stopped }));
+  },
+
+  /** Decisions from OpenRouter's decision model (`AppAI.decide`): `key`, `model`, `state`, `questions`. `{answers, cost}` or `{trouble}`. */
+  async openRouterDecide(given, { stopped } = {}) {
+    return openRouter(() => openRouterDecide({ key: text(given, "key"), model: text(given, "model"), state: given.state, questions: given.questions ?? {},
+      seconds: seconds(given.seconds, 60, 120), signal: stopped }));
+  },
+
+  /** A picture from OpenRouter (`AppAI.image`): `key`, `model`, `prompt`, `references`, `aspectRatio`. `{image, cost}` or `{trouble}`. */
+  async openRouterImage(given, { stopped } = {}) {
+    return openRouter(() => openRouterImage({ key: text(given, "key"), model: text(given, "model"), prompt: text(given, "prompt"),
+      references: given.references, aspectRatio: typeof given.aspectRatio === "string" ? given.aspectRatio : undefined, seconds: seconds(given.seconds, 240, 300), signal: stopped }));
+  },
+
+  /**
+   * One answer from Claude Code or Codex for an app's AI (`AppAI.viaEngine`), sealed as ai.mjs runs every one: `engine`,
+   * the program Lamp chose (`tool`) and what it needs set (`env`), `system`, `prompt`, optional `schema`, `model`,
+   * `images` and `seconds`. `{text}`, or `{trouble: {kind, message}}`; stopping the call stops the engine.
+   */
+  async engineAnswer(given, { stopped } = {}) {
+    try {
+      return { text: await complete({ which: text(given, "engine"), tool: typeof given.tool === "string" && given.tool ? given.tool : undefined,
+        env: given.env && typeof given.env === "object" ? given.env : {}, system: typeof given.system === "string" ? given.system : "",
+        prompt: text(given, "prompt"), schema: given.schema ?? undefined, model: typeof given.model === "string" ? given.model : "",
+        images: Array.isArray(given.images) ? given.images : [], seconds: seconds(given.seconds, 300, 600), signal: stopped }) };
+    } catch (error) {
+      if (error instanceof EngineTrouble) return { trouble: { kind: error.kind, message: error.message } };
+      throw error;
+    }
+  },
+
+  /**
+   * A step of an app's `LampAI.act` as the page sent it (`text`, its JSON), checked: `{step}`, the step as the other
+   * act calls take it, or `{refused: {status, error}}` for the page.
+   */
+  async actStep(given) {
+    try { return { step: readStep(text(given, "text")) }; } catch (error) {
+      if (error instanceof StepRefused) return { refused: { status: error.status, error: error.message } };
+      throw error;
+    }
+  },
+
+  /**
+   * What a step's route is asked: `way` "chat" is a chat with tools (`{body}`, OpenRouter's own when `model` names one),
+   * "plan" one prompt held to the step's shape (`{system, prompt, schema}`), and "words" one with the shape said in it.
+   */
+  async actAsk(given) {
+    const step = given.step, tag = text(given, "tag"), retry = typeof given.retry === "string" ? given.retry : null;
+    if (given.way === "chat") return { body: chatBody(step, tag, retry, typeof given.model === "string" ? given.model : undefined) };
+    return { ...planPrompt(step, tag, retry, given.way === "words"), schema: planSchema(step) };
+  },
+
+  /** A step's answer read and checked: `message` from a chat with tools, or `plan`'s text. `{answer}` or `{problem}`. */
+  async actRead(given) {
+    return given.message !== undefined ? readMessage(given.message, given.step) : readPlan(String(given.plan ?? ""), given.step);
+  },
+
+  /** A decision asked of a text model: `{system, prompt, schema}`. */
+  async decideAsk(given) {
+    return decidePrompt(given.state, given.questions ?? {});
+  },
+
+  /** A text model's decision read: `{answers}` or `{problem}`. */
+  async decideRead(given) {
+    return readDecision(String(given.text ?? ""), given.questions ?? {});
+  },
+
+  /**
+   * Answers the AI of pages shared on lamp.dev, played in a browser on this computer, as `lamp ai` does
+   * (local-ai.mjs), for as long as Lamp's app wants it: which pages are let in, and how, is lamp's alone. The person is
+   * asked by Lamp's app, and the AI is Lamp's: each is an event, `{ask: n, id, name}` or `{answer: n, path, body}`,
+   * which Lamp's app answers with `sharedPagesReply`. A problem when something else answers on this computer already.
+   */
+  async sharedPages(given, { stopped, event } = {}) {
+    const fromLamp = (kind, fields) => new Promise((done) => {
+      const n = ++sharedPagesAsked;
+      sharedPagesWaiting.set(n, done);
+      event({ [kind]: n, ...fields });
+    });
+    let server;
+    try {
+      server = await serveLocalAI({
+        ...(Number.isInteger(given.port) ? { port: given.port } : {}),
+        said: () => {},
+        ask: (_question, page) => fromLamp("ask", { id: page.id, name: page.name }).then((reply) => reply.yes === true),
+        answer: (path, body, page) => fromLamp("answer", { path, body, id: page.id }).then((reply) => [Number(reply.status) || 502, reply.reply ?? {}]),
+      });
+    } catch (error) {
+      if (error?.code === "EADDRINUSE") throw new Problem("lamp ai already answers shared pages' AI on this computer");
+      throw error;
+    }
+    await new Promise((done) => (stopped?.aborted ? done() : stopped?.addEventListener("abort", done)));
+    server.close();
+    return {};
+  },
+
+  /** The pages shared on lamp.dev allowed to use the AI here, for Settings: `{pages: [{origin, id, name, at}]}`, newest first. */
+  async sharedPagesAllowed() {
+    return { pages: Object.entries(pagesAllowed()).map(([origin, page]) => ({ origin, id: page.id, name: page.name, at: page.at }))
+      .sort((a, b) => String(b.at).localeCompare(String(a.at))) };
+  },
+
+  /** Takes back one page's leave to use the AI here (`origin`): it asks again the next time. */
+  async sharedPagesForget(given) {
+    forgetPage(text(given, "origin"));
+    return {};
+  },
+
+  /** Lamp's app's answer to what `sharedPages` asked it: `{n, yes}` or `{n, status, reply}`. */
+  async sharedPagesReply(given) {
+    const done = sharedPagesWaiting.get(given.n);
+    sharedPagesWaiting.delete(given.n);
+    done?.(given);
+    return {};
+  },
+
   /** A search of the home network for one search target, for a few seconds: every answer. */
   async search(given) {
     return { answers: await ssdp(typeof given.target === "string" ? given.target : "ssdp:all", seconds(given.seconds, 2)) };
@@ -358,11 +554,19 @@ async function once(name) {
 async function serve() {
   const say = (line) => process.stdout.write(JSON.stringify(line) + "\n");
   const under = new Map();
+  // A stop can overtake the call it's for (Lamp's app cancelled it as it was sent): it's kept, and the call starts stopped.
+  const early = new Set();
   const answer = async (line) => {
     let asked;
     try { asked = JSON.parse(line); } catch { return; }
-    if (asked?.stop !== undefined) return void under.get(asked.stop)?.abort();
+    if (asked?.stop !== undefined) {
+      const stopping = under.get(asked.stop);
+      if (stopping) stopping.abort();
+      else { early.add(asked.stop); if (early.size > 1000) early.delete(early.values().next().value); }
+      return;
+    }
     const id = asked?.id, call = CALLS[asked?.call], stopping = new AbortController();
+    if (early.delete(id)) stopping.abort();
     under.set(id, stopping);
     try {
       if (!call) throw new Error(`lamp has no call named "${asked?.call ?? ""}"`);

package/cli/dev.mjs

@@ -3,7 +3,9 @@
 //
 // A game made with Lamp's runtime (lamp-game.js beside the page) keeps the player's place: the runtime is handed the
 // change exactly as Lamp's app around the page hands it over (`window.__lampLive`), and swaps the code in, runs it
-// again in place, or opens the page again from where the player was. Any other page is opened again.
+// again in place, or opens the page again from where the player was. A game's page that doesn't run on the runtime is
+// handed it too, through lamp-live.js (given after page.js), which puts in what it safely can and holds the rest for
+// Reload. Any other page is opened again.
 
 import { createServer } from "node:http";
 import { createHash, randomBytes } from "node:crypto";
@@ -13,8 +15,9 @@ import { networkInterfaces, hostname } from "node:os";
 import { join, resolve, extname, sep, relative, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
-import { Problem, RESOURCES, layoutOf, stateOf, logFileOf, serverFileOf, firstPortOf } from "./state.mjs";
-import { findBrowser, launch, keyNamed } from "./browser.mjs";
+import { NOTES_FILE, Problem, RESOURCES, layoutOf, stateOf, logFileOf, serverFileOf, firstPortOf } from "./state.mjs";
+import { findBrowser, noBrowser, launch, keyNamed } from "./browser.mjs";
+import { answer as answerAI } from "./ai.mjs";
 
 const TYPES = {
   ".html": "text/html; charset=utf-8", ".htm": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8",
@@ -37,10 +40,13 @@ export default {"keys":{"AltLeft":"Alt / Option","AltRight":"Alt / Option","Back
 `;
 const HERE = dirname(fileURLToPath(import.meta.url));
 const PAGE_SCRIPT = readFileSync(join(HERE, "page.js"), "utf8");
+// What a game's page is given after lamp's script, as Lamp's app gives it (`LampPageLive.gameScript`): a game that
+// doesn't run on Lamp's runtime takes a change while it's played where it can. Read from Lamp's own copy.
+const GAME_SCRIPT = (() => { try { return readFileSync(join(RESOURCES, "GameKit", "page", "lamp-live.js"), "utf8"); } catch { return ""; } })();
 // Lamp's building blocks for a page (saved data, the app's files, AI through Lamp's app): lamp.js, which Lamp's app
 // writes at each build from its own code. A page whose folder has none is given it as that code writes it, when it has
 // been written out for the command line (scripts/cli-files.sh, cli/lamps/lamp.js), and else a stand-in, so the page loads.
-const LAMP_JS_STAND_IN = "// lamp's stand-in for lamp.js: Lamp's building blocks for a page aren't written out for the command line yet (scripts/cli-files.sh).\n";
+export const LAMP_JS_STAND_IN = "// lamp's stand-in for lamp.js: Lamp's building blocks for a page aren't written out for the command line yet (scripts/cli-files.sh).\n";
 export function lampJS(game = false) {
   // A game's is its own (`GameKit.lampJS`): without a TV's remote, which would take the keys a game reads itself.
   for (const name of game ? ["lamp-for-games.js", "lamp.js"] : ["lamp.js"]) {
@@ -109,9 +115,10 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
 
   // MARK: The files and their changes
 
-  // What's never part of a change: hidden files and folders, what tools keep beside the code, and Lamp's own two files.
+  // What's never part of a change: hidden files and folders, what tools keep beside the code, Lamp's own two files,
+  // and the app's notes, which no page runs (other Markdown may be content a page loads, so it is a change).
   const ignored = (path) => path.split("/").some((part) => part.startsWith(".") || part === "node_modules") || path.endsWith("~")
-    || path === DEVICE_FILE || path === BUILD_FILE;
+    || path === DEVICE_FILE || path === BUILD_FILE || path === NOTES_FILE;
   const filesUnder = (dir = root, prefix = "", found = []) => {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const path = prefix + entry.name;
@@ -136,6 +143,9 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
   const pages = new Map();        // page id → { response, tab, at: the change it has taken, ready, since }
   const reopening = new Map();    // tab → when the page it said it's opening again is given up on
   const early = new Map();        // what a page said before its line for changes was open
+  // Every file of the page a page asked for, by any page since the server started: a change says them, so a game's page
+  // that doesn't run on the runtime tells a file it uses from one it doesn't (lamp-live.js), which no page can see itself.
+  const served = new Set();
   const printed = new Set();
 
   const named = (change) => {
@@ -144,12 +154,19 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
   };
   const tell = (page, event, data, id) => page.response.write(`${id === undefined ? "" : `id: ${id}\n`}event: ${event}\ndata: ${data}\n\n`);
 
+  // What the coding agent said it's changing (`lamp changing`), for the card each page shows as a change goes in: the
+  // changes saved in the few minutes after say it, then it's let go.
+  let changing = null;
+  // What's changing, as the agent last said it: it stands for every save after it, until it says something new or half an
+  // hour has gone by.
+  const changingWords = () => (changing && Date.now() - changing.at < 30 * 60_000 ? { words: changing.words } : {});
+
   function broadcast(changed, removed) {
     gen += 1;
     const change = { gen, changed, removed, said: new Map(), line: logCount };
     changes.push(change);
     if (changes.length > 40) changes.shift();
-    const data = JSON.stringify({ gen, changed, removed, now: false, pill: true });
+    const data = JSON.stringify({ gen, changed, removed, now: false, pill: true, read: [...served], ...changingWords() });
     for (const page of pages.values()) { page.told = Date.now(); tell(page, "change", data, gen); }
     if (!pages.size) print(`${named(change)}: no page is open; it's in the next one opened`);
   }
@@ -331,6 +348,12 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
     checkAll();
     let target = null, problem = null;
     try { target = await watched(); } catch (error) { problem = error.message; }
+    // With no browser lamp can drive, the page is opened in one it can't, and a look straight after can come before
+    // the page has said it's open: the look waits for it, as long as it's given to wait.
+    if (!target && !problem) {
+      const until = Date.now() + Math.max(0, wait) * 1000;
+      while (!pages.size && Date.now() < until) await sleep(100);
+    }
     // Another size is for lamp's own copy: the person's window is the size they made it.
     if (target?.where === "copy") {
       if (size || copySized) await target.page.size(size?.[0], size?.[1]).catch(() => {});
@@ -393,14 +416,15 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
       // Any open page says what's on it; there's no picture without a browser lamp can look into.
       const ask = randomBytes(4).toString("hex"), page = [...pages.values()].pop();
       seen = await new Promise((resolve) => {
-        lookers.set(ask, resolve);
-        setTimeout(() => { lookers.delete(ask); resolve(null); }, 3000);
+        // An answer ends the wait for one, so nothing is left waiting after it.
+        const given = setTimeout(() => { lookers.delete(ask); resolve(null); }, 3000);
+        lookers.set(ask, (answer) => { clearTimeout(given); resolve(answer); });
         tell(page, "look", ask);
       });
       where = "page";
-      problem ??= "No picture: lamp found no browser it can look into (Chrome, Edge, Brave or Chromium).";
+      problem ??= `No picture. ${noBrowser()}`;
     } else {
-      problem ??= "No page is open, and lamp found no browser it can open one in (Chrome, Edge, Brave or Chromium). Open the address in a browser and look again.";
+      problem ??= `No page has opened${wait > 0 ? ` in ${wait} s` : ""}: open ${address} in a browser, then look again. ${noBrowser()}`;
     }
     // How each change since the last look went in the page looked at, or in any page when that one never said. A
     // change a look said was held is said again once it has gone in.
@@ -455,7 +479,7 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
   async function use(asked) {
     const moves = Array.isArray(asked?.moves) ? asked.moves : [asked];
     const target = await watched();
-    if (!target) throw new Problem("lamp found no browser it can use the page in (Chrome, Edge, Brave or Chromium)");
+    if (!target) throw new Problem(`Nothing was done. ${noBrowser()}`);
     // A page still opening, or opening again after a save, would lose what's pressed before it's in: each use waits
     // for its tab, and makes no move in a page that hasn't settled by then.
     let tab = null;
@@ -608,6 +632,11 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
         if (what === "use") return json(200, await inTurn(() => use(asked)));
         if (what === "card") return json(200, await inTurn(() => card(asked)));
         if (what === "open") return json(200, { opened: await openWindow(), url: address });
+        if (what === "changing") {
+          const words = String(asked.words ?? "").replace(/\s+/g, " ").trim();
+          changing = words ? { words: words.length > 120 ? `${words.slice(0, 119).trimEnd()}…` : words, at: Date.now() } : null;
+          return json(200, { pages: pages.size });
+        }
         if (what === "reload") { for (const page of pages.values()) tell(page, "reload", asked.fresh ? "fresh" : "now"); return json(200, { pages: pages.size }); }
         if (what === "stop") { json(200, { stopped: true }); setTimeout(() => close().then(() => process.exit(0)), 50); return; }
         return json(404, { problem: `lamp dev doesn't know "${what}"` });
@@ -616,7 +645,7 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
       }
     }
 
-    if (url.pathname === "/__lamp/page.js") return send(200, TYPES[".js"], `const LAMP = ${JSON.stringify({ gen, run })};\n${PAGE_SCRIPT}`);
+    if (url.pathname === "/__lamp/page.js") return send(200, TYPES[".js"], `const LAMP = ${JSON.stringify({ gen, run })};\n${PAGE_SCRIPT}${layout.game ? `\n${GAME_SCRIPT}` : ""}`);
     if (url.pathname === "/__lamp/events") {
       const id = url.searchParams.get("page") || randomBytes(4).toString("hex"), tab = url.searchParams.get("tab") || id;
       // The last change this page has: what its files were served at, or what it last heard when the line broke.
@@ -636,7 +665,7 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
           for (const path of change.changed) { changed.add(path); removed.delete(path); }
           for (const path of change.removed) { removed.add(path); changed.delete(path); }
         }
-        tell(page, "change", JSON.stringify({ gen, changed: [...changed], removed: [...removed], now: false, pill: true }), gen);
+        tell(page, "change", JSON.stringify({ gen, changed: [...changed], removed: [...removed], now: false, pill: true, read: [...served], ...changingWords() }), gen);
       } else if (missed.length) {
         // More was saved than is remembered: the page opens again from the files as they are.
         tell(page, "reload", "now");
@@ -645,6 +674,23 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
       request.on("close", () => { clearInterval(beat); if (pages.get(id) === page) pages.delete(id); });
       return;
     }
+    // The page's AI (LampAI in lamp.js, through `lampGatewayHost` in page.js): answered here with the person's own
+    // Claude Code or Codex (ai.mjs), only for the page itself on this Mac. Never another site in the person's browser,
+    // which can't send this request's header from another origin, nor another device the server is open to with --lan.
+    if (request.method === "POST" && url.pathname === "/__lamp/ai") {
+      const from = request.socket.remoteAddress || "";
+      const local = from === "127.0.0.1" || from === "::1" || from === "::ffff:127.0.0.1";
+      const origin = request.headers.origin;
+      if (!local || request.headers["x-lamp-page"] !== "1" || (origin && new URL(origin).host !== request.headers.host)) {
+        return json(403, { status: 403, body: JSON.stringify({ error: "The AI answers only the page on this Mac." }) });
+      }
+      const asked = await body(request);
+      const path = typeof asked?.path === "string" ? asked.path : "";
+      let given = {};
+      try { given = typeof asked?.body === "string" ? JSON.parse(asked.body) : asked?.body ?? {}; } catch {}
+      const [status, reply] = await answerAI(path, given);
+      return json(200, { status, body: JSON.stringify(reply) });
+    }
     if (request.method === "POST" && url.pathname.startsWith("/__lamp/")) {
       const message = await body(request);
       if (message && url.pathname === "/__lamp/said") said(message);
@@ -660,6 +706,7 @@ export async function serve({ folder: given, port: asked, lan = false, quiet = f
     let file = resolve(join(root, path));
     if (file !== root && !file.startsWith(root + sep)) return send(403, "text/plain", "Outside the page");
     const name = relative(root, file).split(sep).join("/");
+    served.add(name);
     // Hidden files (.git, .lamp, .env) are no part of the page.
     if (name.split("/").some((part) => part.startsWith("."))) return send(404, "text/plain", "Not found");
     let info;