@lampdotdev/lamp 0.35.0 → 0.36.2-nightly.16

package/cli/lamp.mjs

@@ -10,6 +10,8 @@
 //   lamp use [folder] …   try it: a key, a click, some typing
 //   lamp stop [folder]    stop running it
 //   lamp share [folder]   a link on lamp.dev to play it, and lamp ideas for what people send back
+//   lamp play <link>      play an app shared on lamp.dev here, its AI answered on this computer
+//   lamp ai               the AI of pages shared on lamp.dev, played here, from the person's own Claude Code, Codex or OpenRouter key
 //   lamp devices          the person's devices; lamp open --on xbox, or --on android, puts a page on one
 //   lamp setup            teach the coding agents on this computer to work this way
 //   lamp skills           Lamp's guidance for each kind of work; lamp skill <name> reads one
@@ -21,12 +23,18 @@ import { basename, dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Problem, RESOURCES, layoutOf, manifestOf, projectOf, stateOf, running, ask } from "./state.mjs";
 import { macActions, serveMac, writeMacStarter } from "./mac.mjs";
-import { exportApp, unpack } from "./lampapp.mjs";
-import { updateNotice } from "./update.mjs";
-import { editionName, giveTo, givenTo, keepPictures, reachLamp, takeBack } from "./outside.mjs";
-import { serve, ANY_BROWSER, CONTROLLERS, CONTROLLERS_FILE, DEVICE_FILE, lampJS } from "./dev.mjs";
+import { MAX_ARCHIVE, exportApp, unpack } from "./lampapp.mjs";
+import { latestOf } from "./link.mjs";
+import { updateNotice, versionLine } from "./update.mjs";
+import { editionName, giveTo, givenTo, keepInLamp, keepPictures, lampOwning, lampsKeptLink, reachLamp, takeBack } from "./outside.mjs";
+import { serve, ANY_BROWSER, CONTROLLERS, CONTROLLERS_FILE, DEVICE_FILE, LAMP_JS_STAND_IN, lampJS } from "./dev.mjs";
+import { findBrowser, noBrowser } from "./browser.mjs";
 import { allSkills } from "./skills.mjs";
-import { share, unshare, ideas, finishIdea, readLink, nameOf, siteOrigin, LIMITS } from "./share.mjs";
+import { engine } from "./ai.mjs";
+import { allowed, forgetAllowed, serveLocalAI } from "./local-ai.mjs";
+import { accountFor, keepAccount } from "./share.mjs";
+import { accountName, askAccount } from "./link.mjs";
+import { share, unshare, ideas, finishIdea, answerIdea, makerEmail, readLink, writeLink, forgetLink, nameOf, siteOrigin, LIMITS } from "./share.mjs";
 import { Runner, allKept, fields, forget, integrationOf, isReady, look as lookForDevices, takesPages } from "./devices.mjs";
 import { placeNamed } from "./place.mjs";
 import { androidAdvice, androidDevices, androidDone, emulatorNamed, emulators, forgetAndroid, installTools, knowsAndroid, toolsThere } from "./android.mjs";
@@ -91,6 +99,9 @@ Mac app Lamp made in Swift, built and run on this Mac.
   lamp reload [folder] [--fresh]
       Open the page again from its files, a game from where the player is, or with --fresh from its beginning.
       A Mac app is quit and opened again.
+  lamp changing [folder] <words>
+      Say what you're about to change, in a few words from the person's request ("Rain on the roads"): the open
+      page shows it on the card it puts up as the change goes in, for the next few minutes of changes.
   lamp stop [folder] [--on <device>]
       Stop running it. A Mac app is quit. --on ends it on a device instead (and closes an emulator lamp started
       with no window).
@@ -108,10 +119,33 @@ Mac app Lamp made in Swift, built and run on this Mac.
       person asks. Again, it sends the page as it is now to the same link, with the same words unless new ones are given.
       Its app file goes with it (as lamp export makes it), so anyone can open it in Lamp too; --no-file leaves it out.
       --anyway shares a page that logged errors, or uses work that came with no license.
+      An app of Lamp's (its folder is in Lamp's own, or a link to it) is shared by Lamp's app, which must be running,
+      as its Share Link card shares it: the card's own words, the questions and what's new Lamp writes, the app's
+      file and its GitHub release, with --line, --by, --asks "a|b", --notes "What's new|And more", --no-file,
+      --no-github and --put-on-github in their place. --preview says what would go and sends nothing. Its link
+      stays Lamp's; --new-link has lamp make one of its own instead.
   lamp unshare [folder]   Take the link down.
-  lamp ideas [folder] [in <n> | dismiss <n>]
-      The ideas people playing the link have sent. "in" says one is in the game now (whoever asked to hear is
-      written to); "dismiss" lets one go.
+  lamp ideas [folder] [--earlier | in <n> | dismiss <n> | reply <n> | done <n> | email <address|off>] [note]
+      The ideas people playing the link have sent, with a picture of the app as they saw it when they kept one
+      in, and what's been said about each since. "in" says one is in the game now (whoever asked to hear is
+      written to); "dismiss" lets one go. Words after the number are a note to whoever sent it, on the link's
+      page and in that email; they can answer it by email. "reply" says something more, and "done" leaves
+      their answer without one. --earlier lists those seen to, to look back on or answer again. "email"
+      sends new ideas and replies to your own address too (once you confirm it), and you can answer from there.
+  lamp account [username] [--email you@example.com]
+      Your account on lamp.dev, which your links go under (lamp.dev/<username>/<app>): with a username and an email,
+      asks for it, and an email's link confirms it; with only your email, signs in to the one you have. On its own,
+      says which you're signed in as.
+  lamp play <link> [--to folder] [--newest]
+      Play an app shared on lamp.dev on this computer: its file, unpacked into a folder of its own in
+      ~/Lamp Games (or where --to says), run and opened as lamp dev runs any page, so its AI is answered here in any
+      browser, Safari too. The same link again plays the same folder; --newest takes the link's latest version
+      into a new one.
+  lamp ai [--forget]
+      Answer the AI of pages shared on lamp.dev, played in a browser on this computer, with your own Claude Code
+      or Codex, or OpenRouter with your key in OPENROUTER_API_KEY, until stopped. Lamp does the same while it's
+      open, with the AI you set up there. Each page asks here once, and you allow it or not. --forget takes back
+      every page allowed, so each asks again.
   lamp setup [--remove]   Teach Claude Code and Codex on this computer to work this way (a skill for each).
   lamp guide              What that skill says, for any other agent.
   lamp skills [word]      Lamp's guidance for each kind of work, those about a word; lamp skill <name> reads one.
@@ -130,7 +164,8 @@ const SKILL_MARK = "<!-- Written by lamp setup: run it again to update, or with
 function lampCommand() {
   const me = fileURLToPath(import.meta.url);
   // The copy in Lamp's app is run by its launcher beside it, on the app's own runtime, and updates with Lamp.
-  if (process.env.LAMP_FROM_APP === "1") { const launcher = join(here, "lamp"); return /\s/.test(launcher) ? JSON.stringify(launcher) : launcher; }
+  // A newer copy fetched from npm is run by that same launcher (lamp.sh names it): the app's, never one beside this.
+  if (process.env.LAMP_FROM_APP === "1") { const launcher = process.env.LAMP_LAUNCHER_PATH || join(here, "lamp"); return /\s/.test(launcher) ? JSON.stringify(launcher) : launcher; }
   const found = spawnSync(process.platform === "win32" ? "where" : "which", ["lamp"], { encoding: "utf8" });
   const onPath = found.status === 0 && found.stdout.trim().split("\n").some((path) => { try { return realpathSync(path.trim()) === realpathSync(me); } catch { return false; } });
   return onPath ? "lamp" : `node ${/\s/.test(me) ? JSON.stringify(me) : me}`;
@@ -155,7 +190,8 @@ const quoted = (path) => (/\s/.test(path) ? JSON.stringify(path) : path);
  * Lamp's own files beside a page, which its app writes at every build and a shared file never carries: for a game the
  * runtime, the controllers' list and the device it's on; for any page lamp.js, Lamp's building blocks (a stand-in where
  * Lamp's own isn't beside lamp, never over one); and Lamp's libraries its import map names from beside it. Only those:
- * the page and its code are the project's. `update` writes the game's again over what's there.
+ * the page and its code are the project's. `update` writes again those of them the folder has (lamp.js too), and adds
+ * the game's only to a game: a page that never had them gets none.
  */
 function lampsFilesBeside(root, { game, update = false }) {
   const runtime = join(RESOURCES, "GameKit", "web");
@@ -173,10 +209,13 @@ function lampsFilesBeside(root, { game, update = false }) {
       wrote.push(name);
     }
   }
-  if (!existsSync(join(root, "lamp.js"))) {
-    writeFileSync(join(root, "lamp.js"), lampJS(game));
+  // Updating, only over Lamp's own: a copy of lamp with only the stand-in (a checkout whose generated files aren't
+  // written) never replaces a page's working lamp.js with it.
+  const js = lampJS(game);
+  if (!existsSync(join(root, "lamp.js")) || (update && js !== LAMP_JS_STAND_IN)) {
+    writeFileSync(join(root, "lamp.js"), js);
     wrote.push("lamp.js");
-  }
+  } else if (update) kept.push("lamp.js");
   wrote.push(...addLibraries(root));
   return { wrote, kept };
 }
@@ -216,6 +255,26 @@ function parse(args, valued) {
   return { options, rest };
 }
 
+/**
+ * Who a link says it's by when nothing says, as Lamp's Share Link card fills it (`WishLink.sharer`): the name last given
+ * with `--by`, else the one Lamp's app last shared with, else this computer's account name. The share says it, and
+ * `--by` changes it.
+ */
+function sharer() {
+  try { const kept = readFileSync(sharerFile(), "utf8").trim(); if (kept) return kept; } catch {}
+  for (const bundle of ["dev.lamp.host", "dev.lamp.host.nightly"]) {
+    const said = spawnSync("/usr/bin/defaults", ["read", bundle, "wishLinkSharer"], { encoding: "utf8" });
+    if (said.status === 0 && said.stdout.trim()) return said.stdout.trim();
+  }
+  const name = spawnSync("/usr/bin/id", ["-F"], { encoding: "utf8" });
+  return name.status === 0 ? [...name.stdout.trim()].slice(0, LIMITS.by).join("") : "";
+}
+const sharerFile = () => join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "sharer");
+function keepSharer(name) {
+  mkdirSync(dirname(sharerFile()), { recursive: true });
+  writeFileSync(sharerFile(), name);
+}
+
 /** The server for the folder: the one running, or one started for this command that ends when nothing uses it. */
 async function serverFor(folder) {
   const live = await running(folder);
@@ -392,7 +451,7 @@ const WHERE = {
   mac: "the app as it runs on this Mac",
   window: "the window the person has open",
   copy: "lamp's own copy of the page, which nobody sees (no window is open)",
-  page: "a page open in a browser lamp can't look into",
+  page: "a page open in a browser lamp can't take pictures of or play",
 };
 
 function report(seen) {
@@ -437,6 +496,34 @@ async function inLamp(layout) {
   return lamp;
 }
 
+/**
+ * A folder whose link is Lamp's app's, not lamp's: one of Lamp's apps that lamp has no link of its own for. Its ideas
+ * and taking it down are on Lamp's Share Link card, said so rather than "no link".
+ */
+function lampsLink(folder) {
+  let real = resolve(folder);
+  try { real = realpathSync(real); } catch {}
+  const owner = lampOwning(real);
+  if (!owner) return null;
+  // The link Lamp keeps for its app is lamp's to use too, Lamp open or not.
+  lampsCopy(real);
+  return readLink(real) ? null : editionName(owner);
+}
+
+/**
+ * For an app in a Lamp's own folder: brings lamp's copy of its link in step with the one that Lamp keeps, which is the
+ * link's own record (the person may have changed its words, or stopped sharing and made a new one, in Lamp since).
+ * False when the folder has a link of lamp's own instead (`share --new-link`), which is left as it is.
+ */
+function lampsCopy(folder) {
+  const mine = readLink(folder);
+  if (mine && !mine.fromLamp) return false;
+  const kept = lampsKeptLink(folder);
+  if (kept) writeLink(folder, { ...(mine?.id === kept.id ? mine : {}), ...kept, fromLamp: true });
+  else if (mine) forgetLink(folder);
+  return true;
+}
+
 /** What Lamp's app answered, as lamp says things: how the change went in, its words, and where its pictures are. */
 function lampReport(folder, lamp, answer) {
   const lines = [`${lamp.name}: ${answer.outcome ?? "answered"}.`];
@@ -457,18 +544,26 @@ function letGo(layout, lamp, answer) {
   return true;
 }
 
+/** What the agent last said it's changing in a folder Lamp's app has (`lamp changing`), for half an hour after. */
+function changingFor(folder) {
+  try {
+    const said = JSON.parse(readFileSync(join(stateOf(folder), "changing.json"), "utf8"));
+    return typeof said.words === "string" && Date.now() - said.at < 30 * 60_000 ? { words: said.words } : {};
+  } catch { return {}; }
+}
+
 /**
  * Asks Lamp's app to put what the folder holds into the app (`reopen`: opened again for it), and says how it went.
  * False when Lamp no longer has the folder: the caller runs its own copy instead.
  */
 async function applyInLamp(layout, lamp, { reopen = false } = {}) {
   try {
-    let answer = await lamp.call("apply_change", { path: layout.folder, ...(reopen ? { reopen: true } : {}) });
+    let answer = await lamp.call("apply_change", { path: layout.folder, ...(reopen ? { reopen: true } : {}), ...changingFor(layout.folder) });
     if (letGo(layout, lamp, answer)) return false;
     // Lamp started again since the last apply: it asks for a look at the app as it is first, and then takes the change.
     if (answer.facts?.restarted) {
       await lamp.call("look_at_app", { path: layout.folder });
-      answer = await lamp.call("apply_change", { path: layout.folder, ...(reopen ? { reopen: true } : {}) });
+      answer = await lamp.call("apply_change", { path: layout.folder, ...(reopen ? { reopen: true } : {}), ...changingFor(layout.folder) });
     }
     // Nothing new to put in brings no picture: the app as it is now, which the person may have used since, is looked at.
     if (!answer.pictures.length && ["unchanged", "held"].includes(answer.outcome)) {
@@ -511,8 +606,8 @@ async function devInLamp(layout, lamp) {
     try {
       lamp = lamp ?? (await reachLamp([givenTo(layout.folder)]));
       if (!lamp) { print(`${editionName(givenTo(layout.folder))} isn't running: the change goes in once it is and the next save is made.`); return; }
-      let answer = await lamp.call("apply_change", { path: layout.folder });
-      if (answer.facts?.restarted) { await lamp.call("look_at_app", { path: layout.folder }); answer = await lamp.call("apply_change", { path: layout.folder }); }
+      let answer = await lamp.call("apply_change", { path: layout.folder, ...changingFor(layout.folder) });
+      if (answer.facts?.restarted) { await lamp.call("look_at_app", { path: layout.folder }); answer = await lamp.call("apply_change", { path: layout.folder, ...changingFor(layout.folder) }); }
       if (letGo(layout, lamp, answer)) { stopWatching(false); return; }
       // A folder that changed while Lamp built it is applied again by the next save, or now when it's said so.
       // A folder that changed while Lamp built it goes in again now, saved or not.
@@ -555,6 +650,7 @@ async function devInLamp(layout, lamp) {
 async function main() {
   const [command, ...args] = process.argv.slice(2);
   if (!command || command === "--help" || command === "-h" || command === "help") { console.log(USAGE); return; }
+  if (command === "--version" || command === "-v" || command === "version") { console.log(versionLine()); return; }
 
   if (command === "new") {
     const { options, rest } = parse(args, ["name"]);
@@ -653,10 +749,12 @@ async function main() {
   if (command === "init") {
     const { options, rest } = parse(args, []);
     const layout = layoutOf(rest[0] ?? ".");
-    const { wrote, kept } = lampsFilesBeside(layout.root, { game: true, update: !!options.update });
+    // Updating, a page is a game only if it has the runtime already; setting one up, it becomes one.
+    const game = options.update ? existsSync(join(layout.root, "lamp-game.js")) : true;
+    const { wrote, kept } = lampsFilesBeside(layout.root, { game, update: !!options.update });
     console.log(wrote.length ? `Lamp's own files are beside the page in ${layout.root}: ${wrote.join(", ")}.` : `Lamp's own files were beside the page already in ${layout.root}.`);
     if (kept.length) console.log(`Left as they were: ${kept.join(", ")} (lamp init --update writes them again).`);
-    console.log(`The game takes the runtime up in its own code. Lamp's game-live skill says how (${lampCommand()} skill game-live), and lamp-game.js's own comments are the whole interface.`);
+    if (game) console.log(`The game takes the runtime up in its own code. Lamp's game-live skill says how (${lampCommand()} skill game-live), and lamp-game.js's own comments are the whole interface.`);
     return;
   }
 
@@ -790,7 +888,7 @@ async function main() {
       console.log(opened.running ? `${opened.url} is open.` : opened.building ? `${opened.url} is being built, and opens when it is: lamp look waits for it.` : `${opened.url} didn't build: lamp look says why.`);
       return;
     }
-    console.log(opened.opened === "window" ? `Opened in a window: ${opened.url}` : `Opened in the browser: ${opened.url}\nlamp found no browser it can look into (Chrome, Edge, Brave or Chromium), so looks have no picture.`);
+    console.log(opened.opened === "window" ? `Opened in a window: ${opened.url}` : `Opened in the browser: ${opened.url}\n${noBrowser()}`);
     return;
   }
 
@@ -819,20 +917,74 @@ async function main() {
       }
     }
     if (!any) console.log(options.remove ? "There was no skill of lamp's to take away." : "Neither Claude Code nor Codex is set up on this computer. `lamp guide` prints what to give another agent.");
+    // Web apps and games are looked at and played in a browser lamp drives: said now, before a first look comes back
+    // without a picture. Only said, never a failure: a Mac app needs no browser, and one can be installed later.
+    if (!options.remove && !findBrowser()) console.log(`For web apps and games: ${noBrowser()}`);
     return;
   }
 
   if (command === "share") {
-    const { options, rest } = parse(args, ["name", "words", "line", "by", "asks", "shape"]);
+    const { options, rest } = parse(args, ["name", "words", "line", "by", "asks", "shape", "notes"]);
+    // An app of Lamp's, with no link of lamp's own: shared by Lamp's app, as its Share Link card shares it, filled as the
+    // card fills itself (its last words, the questions and what's new Lamp writes, its file, its GitHub), with what's
+    // given here in their place. Its link's secret stays in Lamp.
+    // By its folder alone: Lamp's app shares kinds lamp doesn't run itself (an iPhone app, a wish of several). Only a
+    // folder that's a Lamp's: one in its own folder, or one given to it (`lamp open --in-lamp`). Any other folder is
+    // lamp's to share, whatever Lamp is running.
+    const project = { folder: (() => { const given = resolve(rest[0] ?? "."); try { return realpathSync(given); } catch { return given; } })() };
+    const owner = lampOwning(project.folder), given = owner ? null : givenTo(project.folder);
+    const hasPage = (() => { try { layoutOf(project.folder); return true; } catch { return false; } })();
+    // An app with a page in a Lamp's own folder is lamp's to share, whether that Lamp is open or not, to the link the
+    // Lamp keeps for it, and its Share Link card is told what went (`keepInLamp`). Only what lamp doesn't pack itself
+    // (a Mac app, an iPhone app, a wish of several) goes through Lamp's app.
+    // A link of lamp's own (--new-link) is a new one, never lamp's copy of the link Lamp keeps.
+    if (options["new-link"] && readLink(project.folder)?.fromLamp) forgetLink(project.folder);
+    const lampsOwn = owner && hasPage && !options["new-link"] && lampsCopy(project.folder);
+    if (!lampsOwn && !readLink(project.folder) && !options["new-link"] && (owner || given)) {
+      const lamp = await reachLamp([owner ?? given]);
+      if (lamp) {
+        const list = (text) => String(text).split("|").map((item) => item.trim()).filter(Boolean);
+        const values = {
+          path: project.folder, ...(options.preview ? { preview: true } : {}),
+          ...(options.by !== undefined ? { by: String(options.by) } : {}),
+          ...(options.line ?? options.words) !== undefined ? { line: String(options.line ?? options.words) } : {},
+          ...(options.asks !== undefined ? { asks: list(options.asks) } : {}), ...(options.notes !== undefined ? { notes: list(options.notes) } : {}),
+          ...(options["no-file"] ? { file: false } : {}), ...(options["no-github"] ? { github: false } : {}),
+          ...(options["put-on-github"] ? { put_on_github: true } : {}),
+        };
+        console.log(options.preview ? `This is an app of ${lamp.name}'s: it shares it, to the link it has, as its Share Link card would.`
+          : `Sharing through ${lamp.name}, as its Share Link does…`);
+        let answer;
+        try { answer = await lamp.call("share_link", values); } finally { lamp.close(); }
+        // A Lamp from before it shared for lamp: an app of its own waits for it to be updated, since a link of lamp's
+        // would be a second one; a folder only given to it is lamp's to share.
+        // lamp shares only a page, so a Mac app given to it waits for Lamp too.
+        const older = /has no tool share_link\b/.test(answer.words ?? "");
+        if (older && (owner || !hasPage)) throw new Problem(`${lamp.name} is older than this lamp and can't share for it: update ${lamp.name}, then run this again${hasPage ? " (or --new-link to make lamp a link of its own)" : ""}.`);
+        if (older) console.log(`${lamp.name} can't share for lamp yet, so lamp shares it with a link of its own.`);
+        else if (answer.facts?.taken_on !== false) {
+          console.log(answer.words);
+          if (answer.failed) process.exitCode = 1;
+          return;
+        }
+      } else if (owner) {
+        throw new Problem(`${editionName(owner)} packs this kind of app for its link: open ${editionName(owner)}, then run this again.`);
+      }
+    }
     const layout = layoutOf(rest[0] ?? ".");
     const before = readLink(layout.folder)?.site === siteOrigin() ? readLink(layout.folder) : null;
     // The link's words: what's given now, else what it went out with before. Its name, where nothing says, is the page's.
     const words = {
       name: String(options.name ?? before?.name ?? nameOf(layout)).trim(), words: String(options.words ?? before?.words ?? "").trim(),
-      line: String(options.line ?? before?.line ?? "").trim(), by: String(options.by ?? before?.by ?? "").trim(),
+      line: String(options.line ?? before?.line ?? "").trim(), by: String(options.by ?? before?.by ?? sharer()).trim(),
       asks: options.asks !== undefined ? String(options.asks).split("|").map((ask) => ask.trim()).filter(Boolean) : before?.asks ?? [],
     };
     const count = (text) => [...new Intl.Segmenter("en", { granularity: "grapheme" }).segment(text)].length;
+    if (options.preview) {
+      console.log(`Nothing was shared. This is what would go:\n${before ? `The link ${before.url}` : "A new link"} for "${words.name}"${words.by ? ` by ${words.by}` : ""}: ${words.line || words.words || "(no words yet: give --words)"}`);
+      console.log(`Questions its page asks: ${words.asks.length ? words.asks.join(" · ") : "the page's own"}\nThe app's file: ${options["no-file"] ? "doesn't go" : "goes with it"}`);
+      return;
+    }
     if (!words.words) throw new Problem('a link says what the page is: share it with --words "What it is, in a sentence or a few"');
     if (!words.name || count(words.name) > LIMITS.name) throw new Problem(`a link's name is at most ${LIMITS.name} characters: --name "Its Name"`);
     if (count(words.words) > LIMITS.words) throw new Problem(`a link's words are at most ${LIMITS.words} characters`);
@@ -851,39 +1003,174 @@ async function main() {
       if (options.shape !== "fill" && !ratio) throw new Problem("--shape is fill, for a page that takes any window, or a shape like 16:9");
       shape = ratio ? Math.round((Number(ratio[1]) / Number(ratio[2])) * 10000) / 10000 : "fill";
     }
-    const sent = await share({ layout, words, shape, picture: card.picture ? Buffer.from(card.picture, "base64") : null, said: (line) => console.log(line),
-      file: !options["no-file"], anyway: !!options.anyway });
+    // A name given is the one every later link says it's by, as Lamp's Share Link card keeps it: kept once the share is
+    // checked and about to go, so a share refused leaves it as it was.
+    if (options.by !== undefined) keepSharer(words.by);
+    let sent;
+    try {
+      sent = await share({ layout, words, shape, picture: card.picture ? Buffer.from(card.picture, "base64") : null, said: (line) => console.log(line),
+        file: !options["no-file"], anyway: !!options.anyway, fromLamp: !!lampsOwn });
+    } finally {
+      // Lamp is told of the link even when its page didn't go, so its card has the link that's out, not a second one.
+      const link = lampsOwn ? readLink(layout.folder) : null;
+      if (link) keepInLamp(layout.folder, link);
+    }
     console.log(`${before ? "Sent again to its link" : "Shared"}: ${sent.url}`);
-    console.log(`"${words.name}"${words.by ? ` by ${words.by}` : ""}: ${sent.files} files, ${(sent.bytes / 1_000_000).toFixed(1)} MB packed, ${shape === "fill" ? "filling the window" : "on its own stage"}${sent.picture ? ", with a picture of it" : ", with no picture"}${sent.file ? ", and its app file, for anyone to open in Lamp" : ""}.`);
+    console.log(`"${words.name}"${words.by ? ` by ${words.by}` : ""}: ${sent.files} files, ${(sent.bytes / 1_000_000).toFixed(1)} MB packed, ${shape === "fill" ? "filling the window" : "on its own stage"}${sent.picture ? ", with a picture of it" : ", with no picture"}${sent.file ? ", and its app file, for anyone to open in Lamp" : ""}${sent.github ? `, with a link to its code on GitHub (${sent.github})` : ""}.`);
     console.log("Anyone with the link can play it and send an idea: lamp ideas shows them. lamp unshare takes it down.");
+    if (words.by && options.by === undefined) console.log(`It says it's by ${words.by}; --by "Another Name" changes that, for this link and the next.`);
+    if (/\/w\//.test(sent.url)) console.log(`${lampCommand()} account <username> --email you@example.com gives your links lamp.dev/<username>/<app>, this one at its next share.`);
     return;
   }
 
   if (command === "unshare") {
     const { rest } = parse(args, []);
-    console.log(`Taken down: ${await unshare(layoutOf(rest[0] ?? ".").folder)}`);
+    const lamps = lampsLink(rest[0] ?? ".");
+    if (lamps) throw new Problem(`${lamps} keeps this app's link: take it down from its Share Link card (Stop Sharing).`);
+    const folder = layoutOf(rest[0] ?? ".").folder;
+    // Lamp's record goes only when the link taken down is the one it keeps, not a link of lamp's own beside it.
+    const taken = readLink(folder);
+    const lampsKept = lampOwning(folder) ? lampsKeptLink(folder) : null;
+    console.log(`Taken down: ${await unshare(folder)}`);
+    if (lampsKept && taken?.id === lampsKept.id) keepInLamp(folder, null);
     return;
   }
 
+  if (command === "account") {
+    const { options, rest } = parse(args, ["email"]);
+    const site = siteOrigin();
+    if (options.email === undefined) {
+      const kept = accountFor(site);
+      if (!kept) { console.log(`No account yet: ${lampCommand()} account <username> --email you@example.com asks for one.`); return; }
+      const name = await accountName({ site, key: kept.key });
+      console.log(name ? `Signed in as ${name}: your links go under ${new URL(site).host}/${name}.`
+        : `Waiting for you to open the link in the email for ${kept.username}. Until then, links are shared as before.`);
+      return;
+    }
+    const asked = await askAccount({ site, username: rest[0], email: String(options.email) });
+    keepAccount(site, { username: asked.username, key: asked.key, email: String(options.email) });
+    console.log(`${asked.existing ? `Signing in as ${asked.username}` : `Asking for ${asked.username}`}: open the link in the email sent to ${options.email} to confirm it.`
+      + (asked.sent === false ? " (The site couldn't send it just now: ask again in a moment.)" : ""));
+    return;
+  }
+
+  if (command === "play") {
+    const { options, rest } = parse(args, ["to"]);
+    let id = /(?:^|\/w\/)([A-Za-z0-9]{10})(?:-|$|\/|\?|#)/.exec(rest[0] ?? "")?.[1];
+    // A link by its maker's username and its name there (lamp.dev/<username>/<app>): its id, asked of the site.
+    let latest;
+    if (!id) {
+      const named = /^https?:\/\/[^/]+\/([a-z0-9-]{1,60})\/([a-z0-9-]{1,60})\/?(?:[?#]|$)/.exec(rest[0] ?? "");
+      if (named) { latest = await latestOf({ user: named[1], app: named[2] }); id = latest?.id ?? null; }
+      if (named && !id) throw new Problem("that link isn't on lamp.dev, or it has been taken down");
+    }
+    if (!id) throw new Problem("play takes a link to an app shared on lamp.dev: lamp play https://lamp.dev/matt-rubens/bricks");
+    // Which folder each link was played into, so playing it again picks up where it was, saves and all: a file of its
+    // own for each link, so two links played at once never write over each other's.
+    const playedFile = join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "played", id);
+    let recorded = null;
+    try { recorded = readFileSync(playedFile, "utf8").trim() || null; } catch {}
+    const wanted = options.to ? resolve(options.to) : null;
+    let folder = !options.newest && recorded && (!wanted || wanted === recorded) && existsSync(join(recorded, "lamp-app.json")) ? recorded : null;
+    if (folder) console.log(`Playing the copy in ${folder}. --newest takes the link's latest version instead.`);
+    else {
+      latest ??= await latestOf({ id });
+      if (!latest) throw new Problem("that link isn't on lamp.dev, or it has been taken down");
+      if (!latest.file) throw new Problem(`"${latest.name ?? "That app"}" was shared without its file, so it plays only on lamp.dev`);
+      const answer = await fetch(latest.file);
+      const bytes = answer.ok ? Buffer.from(await answer.arrayBuffer()) : null;
+      if (!bytes) throw new Problem("its file couldn't be downloaded; try again in a moment");
+      if (bytes.length > MAX_ARCHIVE) throw new Problem("its file is bigger than a Lamp app file is let be");
+      const name = String(latest.name || "Shared app").replace(/[\r\n/:\\]+/g, " ").trim().slice(0, 60) || "Shared app";
+      const games = join(homedir(), "Lamp Games");
+      folder = wanted ?? join(games, name);
+      for (let n = 2; !options.to && existsSync(folder) && readdirSync(folder).length; n++) folder = join(games, `${name} ${n}`);
+      const work = join(stateOf(folder), "download.lampapp");
+      mkdirSync(dirname(work), { recursive: true });
+      writeFileSync(work, bytes);
+      let opened;
+      try { opened = unpack(work, folder); } finally { rmSync(work, { force: true }); }
+      if (opened.refused) throw new Problem(`it's unpacked in ${folder}, but lamp can't run it: ${opened.refused}. Open it in Lamp instead`);
+      if (opened.project.kind === "page") lampsFilesBeside(opened.project.root, { game: opened.project.game || manifestOf(folder)?.platform === "game" });
+      mkdirSync(dirname(playedFile), { recursive: true });
+      writeFileSync(playedFile, folder);
+      console.log(`"${opened.name}", version ${latest.version}, is in ${folder}.`);
+    }
+    const opened = await ask(await serverFor(projectOf(folder).folder), "open", {}, { timeout: 30_000 });
+    if (opened.opened === "app") console.log(opened.running ? `${opened.url} is open.` : `${opened.url} is being built, and opens when it is.`);
+    else console.log(opened.opened === "window" ? `Opened in a window: ${opened.url}` : `Opened in the browser: ${opened.url}`);
+    console.log("Its AI is answered here, with your own Claude Code, Codex or OpenRouter key. A change you make stays in this copy.");
+    return;
+  }
+
+  if (command === "ai") {
+    const { options } = parse(args, []);
+    if (options.forget) { forgetAllowed(); console.log("Every shared page asks again before it uses your AI here."); return; }
+    const which = engine();
+    if (!which) throw new Problem("AI here needs Claude Code or Codex on this computer, signed in, or an OpenRouter key in OPENROUTER_API_KEY.");
+    try { await serveLocalAI(); } catch (error) {
+      if (error?.code === "EADDRINUSE") throw new Problem("Lamp, or lamp ai in another terminal, already answers shared pages' AI on this computer.");
+      throw error;
+    }
+    const allowedNow = Object.values(allowed());
+    console.log(`Answering the AI of pages shared on lamp.dev with your ${which === "codex" ? "Codex" : which === "openrouter" ? "OpenRouter key" : "Claude Code"}, as they're played in a browser on this computer. Ctrl-C stops.`);
+    if (allowedNow.length) console.log(`Allowed: ${allowedNow.map((page) => (page.name ? `"${page.name}"` : `lamp.dev/w/${page.id}`)).join(", ")}.`);
+    await new Promise(() => {});
+  }
+
   if (command === "ideas") {
-    const { rest } = parse(args, []);
-    const outcomes = ["in", "dismiss"];
+    const outcomes = ["in", "dismiss", "reply", "done", "email"];
+    // Everything after the outcome's number is a note to whoever sent it, word for word: never read as options, so
+    // "--fullscreen" or "--help" in it stays in it.
+    const at = args.findIndex((arg) => outcomes.includes(arg));
+    const { options, rest } = parse(at < 0 ? args : args.slice(0, at + 2), []);
+    const noted = at < 0 ? [] : args.slice(at + 2);
     const folder = rest.length && !outcomes.includes(rest[0]) ? rest.shift() : ".";
+    const lamps = lampsLink(folder);
+    if (lamps) throw new Problem(`${lamps} keeps this app's link, and the ideas people send to it: they're on its Share Link card in ${lamps}.`);
     const layout = layoutOf(folder);
+    if (rest[0] === "email") {
+      // The maker's own address for this link's ideas and replies: confirmed by an email first; "off" stops them.
+      const given = [...rest.slice(1), ...noted].join(" ").trim();
+      if (!given) throw new Problem("email takes your address, or off: lamp ideas email you@example.com");
+      const answer = await makerEmail(layout.folder, given === "off" ? "" : given);
+      if (given !== "off" && !answer.confirmed && answer.sent === false) throw new Problem(`lamp.dev couldn't send the confirmation to ${answer.email} just now: try again in a minute`);
+      console.log(given === "off" ? "No more emails about this link's ideas."
+        : answer.confirmed ? `Ideas and replies go to ${answer.email}.` : `Sent a confirmation to ${answer.email}: ideas and replies come there once you confirm it.`);
+      return;
+    }
     if (rest.length) {
       const n = Number(rest[1]);
-      if (!outcomes.includes(rest[0]) || !Number.isInteger(n) || n < 1) throw new Problem("ideas takes in <number> or dismiss <number>: lamp ideas lists them with their numbers");
-      const answer = await finishIdea(layout.folder, n, rest[0] === "in");
-      console.log(rest[0] === "in" ? `Idea ${n} is in.${answer.notified ? " Whoever sent it asked to hear, and has been written to." : ""}` : `Idea ${n} is let go.`);
+      if (!outcomes.includes(rest[0]) || !Number.isInteger(n) || n < 1) throw new Problem("ideas takes in, dismiss, reply or done, and a number: lamp ideas lists them with their numbers");
+      // On the link's page, and in the email if they asked for one.
+      const note = [...rest.slice(2), ...noted].join(" ").trim() || undefined;
+      if (rest[0] === "reply" || rest[0] === "done") {
+        if (rest[0] === "reply" && !note) throw new Problem("reply takes what to say after the number: lamp ideas reply <number> <words>");
+        const answer = await answerIdea(layout.folder, n, rest[0] === "reply" ? note : undefined);
+        console.log(rest[0] === "done" ? `Idea ${n} is seen to.` : `Said to whoever sent idea ${n}${answer.notified ? ", by email too" : ", on the link's page"}.`);
+        return;
+      }
+      const answer = await finishIdea(layout.folder, n, rest[0] === "in", note);
+      console.log(rest[0] === "in" ? `Idea ${n} is in.${answer.notified ? " Whoever sent it asked to hear, and has been written to." : ""}` : `Idea ${n} is let go.${note ? " Your note is on the link's page for them." : ""}`);
       return;
     }
-    const sent = await ideas(layout.folder);
-    if (!sent.ideas.length) { console.log(`No ideas waiting for ${sent.url}`); return; }
-    console.log(`Ideas sent to ${sent.url}`);
+    const [sent, maker] = await Promise.all([ideas(layout.folder, { earlier: options.earlier === true }), makerEmail(layout.folder).catch(() => null)]);
+    if (maker?.email) console.log(maker.confirmed ? `Ideas and replies go to ${maker.email} too.` : `Waiting for ${maker.email} to be confirmed: the link is in the email lamp.dev sent it.`);
+    if (!sent.ideas.length) { console.log(options.earlier ? `Nothing seen to yet on ${sent.url}` : `No ideas waiting for ${sent.url}`); return; }
+    console.log(options.earlier ? `Ideas seen to on ${sent.url}, the latest first` : `Ideas sent to ${sent.url}`);
     for (const idea of sent.ideas) {
-      console.log(`  ${idea.n}. ${String(idea.text).split("\n").join("\n     ")}${idea.wantsNews ? "  (wants to hear when it's in)" : ""}`);
+      const state = options.earlier ? `  (${idea.status === "in" ? "in" : "dismissed"})` : idea.waiting ? `  (${idea.status === "in" ? "in" : idea.status === "dismissed" ? "dismissed" : "open"}, they answered)` : idea.wantsNews ? "  (wants to hear back)" : "";
+      const from = typeof idea.name === "string" && idea.name ? idea.name : null;
+      console.log(`  ${idea.n}. ${from ? `${from}: ` : ""}${String(idea.text).split("\n").join("\n     ")}${state}`);
+      // What's been said since, each way.
+      for (const said of Array.isArray(idea.thread) ? idea.thread : [])
+        console.log(`     ${said.by === "maker" ? "You" : from ?? "They"}: ${String(said.text).split("\n").join("\n       ")}`);
+      // The app as they saw it when they opened the box, if they kept it in: there until the idea has its outcome.
+      if (typeof idea.picture === "string" && idea.picture.startsWith("https://")) console.log(`     picture: ${idea.picture}`);
     }
-    console.log("Say what became of one with: lamp ideas in <number>, or lamp ideas dismiss <number>.");
+    if (options.earlier) { console.log("Say something more with: lamp ideas reply <number> <words>."); return; }
+    console.log("Say what became of one with: lamp ideas in <number>, or lamp ideas dismiss <number>, with a note to them after it if you like.");
+    if (sent.ideas.some((idea) => idea.waiting)) console.log("Answer one with: lamp ideas reply <number> <words>, or lamp ideas done <number> to leave it.");
     return;
   }
 
@@ -897,6 +1184,29 @@ async function main() {
 
   if (command === "devices") return await devices(args);
 
+  if (command === "changing") {
+    // What the next change is, in the person's words, for the card the page shows as it goes in.
+    const named = args.length > 1 && existsSync(args[0]) && statSync(args[0]).isDirectory();
+    const folder = named ? args[0] : ".";
+    const words = (named ? args.slice(1) : args).join(" ").trim();
+    if (!words) throw new Problem('changing takes what you\'re about to change, in a few words: lamp changing "Rain on the roads"');
+    const layout = projectOf(folder);
+    // For a folder Lamp's app has, it goes with the next apply_change (`changingFor`), and its card says it.
+    if (givenTo(layout.folder)) {
+      mkdirSync(stateOf(layout.folder), { recursive: true });
+      writeFileSync(join(stateOf(layout.folder), "changing.json"), JSON.stringify({ words, at: Date.now() }));
+      console.log("The app says so as the change goes in.");
+      return;
+    }
+    // A Mac app lamp runs itself has no card for a change: nothing to say it on, and nothing wrong.
+    if (layout.kind === "mac") { console.log("A Mac app lamp runs itself shows no card for a change: nothing says it."); return; }
+    const live = await running(layout.folder);
+    if (!live) { console.log("lamp dev isn't running for this folder: nothing shows it."); return; }
+    await ask(live, "changing", { words });
+    console.log("The page says so as the change goes in.");
+    return;
+  }
+
   if (command === "reload" || command === "stop") {
     const { options, rest } = parse(args, ["on"]);
     if (options.on !== undefined) {

package/cli/lampapp.mjs

@@ -6,11 +6,13 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { inflateRawSync } from "node:zlib";
-import { Problem, manifestOf, projectOf, stateOf } from "./state.mjs";
+import { Problem, RESOURCES, manifestOf, projectOf, stateOf } from "./state.mjs";
 import { LIMITS, nameOf, zipOf } from "./share.mjs";
 
-// What another Lamp accepts in a file (`Sharing.maxFiles`, `maxUnpackedBytes`, `maxArchiveBytes`).
-export const MAX_FILES = 2000, MAX_UNPACKED = 256 * 1024 * 1024, MAX_ARCHIVE = 64 * 1024 * 1024;
+// What a Lamp app file may hold, written once in Resources/share-rules.json, which Lamp's app reads too (`ShareRules`):
+// the sizes another Lamp opens, the names a license goes by, and the shapes of keys a shared file never carries.
+const RULES = JSON.parse(readFileSync(join(RESOURCES, "share-rules.json"), "utf8"));
+export const MAX_FILES = RULES.limits.files, MAX_UNPACKED = RULES.limits.unpackedBytes, MAX_ARCHIVE = RULES.limits.archiveBytes;
 
 /**
  * The files of a zip, by path: each a regular file's bytes, in the folder it names. A path that leaves the folder, a
@@ -93,17 +95,15 @@ const SERVED_HIDDEN = new Set([".nojekyll", ".well-known"]);
 const SWIFT_LAMPS = new Set(["LampSupport.swift", "LampScene.swift", "LampWidgetSupport.swift", "LampShareSupport.swift"]);
 
 // Shapes of keys and tokens whoever's they are (`ShareCheck.tokenShapes`).
-const TOKEN_SHAPES = [
-  /-----BEGIN [A-Z ]*PRIVATE KEY-----/, /\bsk-(or-v1-|ant-|proj-)?[A-Za-z0-9_\-]{32,}/, /\bgh[pousr]_[A-Za-z0-9]{36,}/, /\bgithub_pat_[A-Za-z0-9_]{60,}/,
-  /\bAKIA[0-9A-Z]{16}\b/, /\bAIza[0-9A-Za-z_\-]{35}\b/, /\bxox[abprs]-[A-Za-z0-9\-]{20,}/, /\b(sk|rk)_live_[A-Za-z0-9]{20,}/,
-];
+const TOKEN_SHAPES = RULES.tokenShapes.map((shape) => new RegExp(shape.pattern));
 
 /** A license text by its name (`Credits.isLicenceFile`): LICENSE, LICENCE, COPYING, NOTICE or UNLICENSE, never code. */
 export function isLicenceFile(path) {
   if (typeof path !== "string" || !path || path.startsWith("/") || path.split("/").some((part) => !part || part === ".." || part === ".")) return false;
   const name = path.split("/").pop(), dot = name.lastIndexOf("."), ext = dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
-  return ["LICENSE", "LICENCE", "COPYING", "NOTICE", "UNLICENSE"].some((start) => name.toUpperCase().startsWith(start))
-    && ext.length <= 10 && /^[a-z0-9]*$/.test(ext) && !["sh", "command", "app", "js", "py", "rb", "pl", "swift", "html", "htm"].includes(ext);
+  const rules = RULES.licenseFiles;
+  return rules.startsWith.some((start) => name.toUpperCase().startsWith(start))
+    && ext.length <= rules.longestExtension && /^[a-z0-9]*$/.test(ext) && !rules.neverExtensions.includes(ext);
 }
 
 /**

package/cli/lamps/android-host/LampPageGateway.kt

@@ -23,8 +23,8 @@ object LampPageGateway {
             val id = call.optInt("id")
             val path = call.optString("path")
             val body = call.optString("body", "{}")
-            // The page's own wait for an answer (a status check's few seconds, a question's minutes).
-            val timeout = call.optInt("timeout", 240_000).coerceIn(1_000, 240_000)
+            // The page's own wait for an answer (a status check's few seconds, an action step's ten minutes at most).
+            val timeout = call.optInt("timeout", 240_000).coerceIn(1_000, 600_000)
             thread {
                 val (status, text) = if (path in routes) post(files, path, body, timeout) else 404 to JSONObject().put("error", "Not found").toString()
                 val answer = JSONObject().put("id", id).put("status", status).put("body", text).toString()