@lampdotdev/lamp 0.35.0 → 0.36.2-nightly.16

package/cli/openrouter.mjs

@@ -0,0 +1,133 @@
+// An app's AI asked of OpenRouter with the person's own key: the one place it's sent, for Lamp's app (`openRouterText`,
+// `openRouterChat`, `openRouterDecide` and `openRouterImage` in calls.mjs; `AppAI.viaOpenRouter`, `AppAct.openRouterStep`,
+// `AppAI.decide` and `AppAI.image`) and for lamp's own answers
+// (ai.mjs, with OPENROUTER_API_KEY). The key comes with each request and is kept nowhere here.
+
+const ENDPOINT = "https://openrouter.ai/api/v1/chat/completions";
+/** The model lamp answers with when none is named: the one Lamp's app offers first for apps' text. */
+export const DEFAULT_MODEL = "anthropic/claude-sonnet-5.5";
+const FILTERED = "The AI provider's content filter cut the reply off. Try rewording the request.";
+
+/** Why OpenRouter gave no answer: `kind` "refused" (with its `status` and `reply`), "filtered", "timeout" or "stopped". */
+export class OpenRouterTrouble extends Error {
+  constructor(kind, message, { status = 0, reply = {}, cost = 0 } = {}) {
+    super(message);
+    Object.assign(this, { kind, status, reply, cost });
+  }
+}
+
+/**
+ * A request for text: the prompt with its pictures (base64, with their `media_type`) and the system prompt. With
+ * `json` the answer must be a JSON object, with room for a long one (a cut-off reply is what breaks apps), and with a
+ * `schema` it must fit it too.
+ */
+export function textBody({ prompt, images = [], system = "", model = DEFAULT_MODEL, json = false, schema } = {}) {
+  const messages = [];
+  if (String(system).trim()) messages.push({ role: "system", content: system });
+  messages.push({ role: "user", content: [{ type: "text", text: prompt },
+    ...(Array.isArray(images) ? images : []).filter((image) => image?.data).map((image) => ({ type: "image_url", image_url: { url: `data:${image.media_type || "image/jpeg"};base64,${image.data}` } }))] });
+  const body = { model, messages, usage: { include: true } };
+  if (json) {
+    body.response_format = schema ? { type: "json_schema", json_schema: { name: "answer", strict: true, schema } } : { type: "json_object" };
+    body.max_tokens = 16000;
+  }
+  return body;
+}
+
+/**
+ * One chat completion: `{message, cost}`, the model's message as OpenRouter gives it (its text, or its tool calls) and
+ * what it cost. A provider's safety filter sometimes refuses an ordinary request at random (finish_reason
+ * "content_filter", an empty reply, HTTP 200), so it's asked again, twice at most, within the same `seconds`.
+ */
+export async function chat({ key, body, seconds = 120, signal, fetcher = fetch }) {
+  const deadline = Date.now() + seconds * 1000;
+  let cost = 0;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    // Whole milliseconds: a timer takes nothing finer, and the seconds given may have more.
+    const left = Math.floor(deadline - Date.now());
+    if (left < 1000) throw new OpenRouterTrouble("timeout", "This ran out of time.", { cost });
+    let answer;
+    try {
+      answer = await fetcher(ENDPOINT, { method: "POST", body: JSON.stringify(body),
+        headers: { Authorization: `Bearer ${key || ""}`, "Content-Type": "application/json", "X-Title": "Lamp" },
+        signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(left)]) : AbortSignal.timeout(left) });
+    } catch (error) {
+      if (signal?.aborted) throw new OpenRouterTrouble("stopped", "Stopped.", { cost });
+      if (error?.name === "TimeoutError" || Date.now() >= deadline) throw new OpenRouterTrouble("timeout", "This ran out of time.", { cost });
+      throw new OpenRouterTrouble("refused", "Couldn't reach OpenRouter.", { cost });
+    }
+    let reply = {};
+    try { reply = await answer.json(); } catch {}
+    cost += Number(reply?.usage?.cost) || 0;
+    const choice = Array.isArray(reply?.choices) ? reply.choices[0] : null;
+    if (answer.status !== 200 || !choice) throw new OpenRouterTrouble("refused", "OpenRouter didn't answer.", { status: answer.status, reply, cost });
+    if (choice.finish_reason === "content_filter") {
+      if (attempt < 2) { await new Promise((done) => setTimeout(done, Math.min(400 << attempt, Math.max(0, deadline - Date.now())))); continue; }
+      throw new OpenRouterTrouble("filtered", FILTERED, { cost });
+    }
+    return { message: choice.message ?? {}, cost };
+  }
+  throw new OpenRouterTrouble("refused", "The AI didn't answer.", { cost });
+}
+
+/** A text answer: `{text, cost}`. */
+export async function text(given) {
+  const { message, cost } = await chat({ ...given, body: textBody(given) });
+  return { text: typeof message.content === "string" ? message.content : "", cost };
+}
+
+/** One request to OpenRouter, within `seconds`: its status and its JSON, or why there was none. */
+async function post(path, { key, body, seconds, signal, fetcher = fetch }) {
+  const timeout = AbortSignal.timeout(Math.floor(seconds * 1000));
+  let answer;
+  try {
+    answer = await fetcher(`https://openrouter.ai/api/v1/${path}`, { method: "POST", body: JSON.stringify(body),
+      headers: { Authorization: `Bearer ${key || ""}`, "Content-Type": "application/json", "X-Title": "Lamp" },
+      signal: signal ? AbortSignal.any([signal, timeout]) : timeout });
+  } catch (error) {
+    if (signal?.aborted) throw new OpenRouterTrouble("stopped", "Stopped.");
+    if (error?.name === "TimeoutError") throw new OpenRouterTrouble("timeout", "This ran out of time.");
+    throw new OpenRouterTrouble("refused", "Couldn't reach OpenRouter.");
+  }
+  let reply = {};
+  try { reply = await answer.json(); } catch {}
+  return { status: answer.status, reply: reply && typeof reply === "object" ? reply : {} };
+}
+
+/**
+ * Decisions from a decision model (`LampAI.decide`, `AppAI.decide`): `{answers, cost}`. Rate limits (429) and overload
+ * (529) are expected under load, so it backs off and asks again three times at most. A request the model can't take
+ * (422) is "invalid", with what it said.
+ */
+export async function decide({ key, model, state, questions, seconds = 60, signal, fetcher }) {
+  for (let attempt = 0; attempt < 4; attempt++) {
+    const { status, reply } = await post("systemone", { key, body: { state, model, questions }, seconds, signal, fetcher });
+    if ((status === 429 || status === 529) && attempt < 3) { await new Promise((done) => setTimeout(done, 500 << attempt)); continue; }
+    if (status !== 200 || !reply.answers || typeof reply.answers !== "object") {
+      const detail = reply.error?.message ?? (reply.detail !== undefined ? String(typeof reply.detail === "string" ? reply.detail : JSON.stringify(reply.detail)) : `HTTP ${status}`);
+      throw new OpenRouterTrouble(status === 422 ? "invalid" : "refused", status === 422 ? `The decision request was invalid: ${detail}` : "The decision model didn't answer.", { status, reply });
+    }
+    // Jev charges per input token ($0.042 per million); OpenRouter may report the exact cost.
+    // A cost OpenRouter reports stands, nothing included; the estimate is only for when it reports none.
+    const reported = reply.usage?.cost;
+    const cost = typeof reported === "number" && Number.isFinite(reported) ? reported : (Number(reply.usage?.input_tokens) || 0) * 0.042 / 1_000_000;
+    return { answers: reply.answers, cost };
+  }
+  throw new OpenRouterTrouble("busy", "The decision model is busy. Try again in a moment.");
+}
+
+/**
+ * A picture from an image model (`LampAI.makeImage` and its edits, `AppAI.image`): `{image, cost}`, the PNG in base64.
+ * `references` are the pictures to edit or build on (base64, with their `media_type`).
+ */
+export async function image({ key, model, prompt, references = [], aspectRatio, seconds = 240, signal, fetcher }) {
+  const body = { model, prompt, n: 1, output_format: "png" };
+  if (aspectRatio) body.aspect_ratio = aspectRatio;
+  const given = (Array.isArray(references) ? references : []).filter((reference) => reference?.data);
+  if (given.length) body.input_references = given.map((reference) => ({ type: "image_url", image_url: { url: `data:${reference.media_type || "image/png"};base64,${reference.data}` } }));
+  const { status, reply } = await post("images", { key, body, seconds, signal, fetcher });
+  if (status !== 200) throw new OpenRouterTrouble("refused", "The image model didn't answer.", { status, reply });
+  const picture = Array.isArray(reply.data) ? reply.data[0]?.b64_json : null;
+  if (typeof picture !== "string" || !picture) throw new OpenRouterTrouble("empty", "The image model didn't return a picture.", { reply });
+  return { image: picture, cost: Number(reply.usage?.cost) || 0 };
+}

package/cli/outside.mjs

@@ -6,9 +6,9 @@
 // carries the folder's path there and the answer back.
 
 import { createConnection } from "node:net";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { Problem, stateOf } from "./state.mjs";
 
 // The handshake's version, as Lamp's helper sends it (`OutsideKit.protocolVersion`).
@@ -113,6 +113,20 @@ export function answerOf(result) {
   return { outcome, facts, words, pictures, failed: result?.isError === true };
 }
 
+/**
+ * The Lamp whose own folder an app's is in (`~/Library/Application Support/<Lamp>/Apps/…`, followed through a link to
+ * it), by its bundle id, or null for a folder of anyone else's.
+ */
+export function lampOwning(folder) {
+  let real = folder;
+  try { real = realpathSync(folder); } catch {}
+  const name = new RegExp(`${join(homedir(), "Library", "Application Support").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/(Lamp(?: Nightly| Dev(?: [A-Za-z0-9-]+)?)?)/Apps/`).exec(real)?.[1];
+  if (!name) return null;
+  if (name === "Lamp") return "dev.lamp.host";
+  if (name === "Lamp Nightly") return "dev.lamp.host.nightly";
+  return name === "Lamp Dev" ? "dev.lamp.host.dev" : `dev.lamp.host.dev.${name.slice("Lamp Dev ".length)}`;
+}
+
 // MARK: Which folders are Lamp's app's
 
 const markOf = (folder) => join(stateOf(folder), "in-lamp.json");
@@ -138,3 +152,52 @@ export function keepPictures(folder, pictures) {
     return path;
   });
 }
+
+/**
+ * The link Lamp's app keeps for an app in its own folder (its "Wish Links.json", by the app's instance id), as lamp
+ * keeps a link (`readLink`), or null. lamp shares such an app itself, to the same link, whether Lamp is open or not.
+ */
+export function lampsKeptLink(folder) {
+  const where = keptLinkOf(folder);
+  if (!where) return null;
+  let kept;
+  try { kept = JSON.parse(readFileSync(where.file, "utf8"))[where.key]; } catch { return null; }
+  if (typeof kept?.id !== "string" || typeof kept.secret !== "string" || typeof kept.url !== "string") return null;
+  const shown = kept.shown ?? {};
+  let site = "https://lamp.dev";
+  try { site = new URL(kept.url).origin; } catch {}
+  return { site, id: kept.id, url: kept.url, secret: kept.secret, name: shown.name ?? "", words: shown.words ?? "", line: shown.line ?? "",
+    by: shown.by ?? "", asks: shown.asks ?? [], ...(shown.file ? { file: true } : {}) };
+}
+
+/** Tells Lamp's app what lamp shared to an app's link (or, with none, that it was taken down), so its Share Link card
+ * shows the link as it is now. */
+export function keepInLamp(folder, link) {
+  const where = keptLinkOf(folder);
+  if (!where) return;
+  let all = {};
+  try { all = JSON.parse(readFileSync(where.file, "utf8")) || {}; } catch {}
+  const was = all[where.key] ?? {};
+  // Taken down: Lamp's card has no link for it any more.
+  if (!link) delete all[where.key];
+  else all[where.key] = { ...was, id: link.id, url: link.url, secret: link.secret,
+    // Its picture isn't the one Lamp took (Lamp knows its own by a digest), so the card offers to send Lamp's again.
+    shown: { ...(({ picture: _picture, ...rest }) => rest)(was.shown ?? {}), name: link.name, words: link.words, line: link.line, by: link.by,
+      asks: link.asks ?? [], file: link.file ? true : undefined,
+      ...(link.shape !== undefined ? { shape: link.shape === "fill" ? "fill" : Number(link.shape).toFixed(4) } : {}) } };
+  mkdirSync(dirname(where.file), { recursive: true });
+  writeFileSync(where.file, JSON.stringify(all), { mode: 0o600 });
+}
+
+/** Where Lamp's app keeps an app's link: its Lamp's "Wish Links.json", under the app's instance id (`.lamp/meta.json`). */
+function keptLinkOf(folder) {
+  let real = folder;
+  try { real = realpathSync(folder); } catch {}
+  const at = real.lastIndexOf("/Apps/");
+  if (!lampOwning(real) || at < 0) return null;
+  const app = join(real.slice(0, at), "Apps", real.slice(at + 6).split("/")[0]);
+  let meta;
+  try { meta = JSON.parse(readFileSync(join(app, ".lamp", "meta.json"), "utf8")); } catch { return null; }
+  const key = typeof meta?.instance === "string" && meta.instance ? meta.instance : meta?.id;
+  return typeof key === "string" && key ? { file: join(real.slice(0, at), "Wish Links.json"), key } : null;
+}

package/cli/page.js

@@ -5,6 +5,7 @@
   // game's code left running each time that code runs again, and a timer of lamp's set through the page's
   // `setTimeout` would go with them, and the log with it.
   const later = window.setTimeout.bind(window), ask = window.fetch.bind(window);
+  const unlater = window.clearTimeout.bind(window), every = window.setInterval.bind(window), unevery = window.clearInterval.bind(window);
   // A page opened again to show its beginning (`lamp look --reopen`) says so to the game runtime, which then starts
   // the game from its start, its saves kept (`window.lampFreshStart` in lamp-game.js).
   const FRESH = 'lamp.dev.fresh';
@@ -19,10 +20,154 @@
   };
   const said = message => post('said', message, true);
 
+  // MARK: The page's AI
+  // LampAI in lamp.js reaches Lamp's app through a host bridge when the app shows the page; here lamp itself answers
+  // (`/__lamp/ai`, with the person's own Claude Code or Codex), through the same shape of bridge lamp.js takes from
+  // Lamp's Android app: postMessage of a request, an onmessage with its answer.
+  if (!window.lampGatewayHost && !(window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.lampGateway)) {
+    const gateway = { onmessage: null };
+    gateway.postMessage = (text) => {
+      let asked;
+      try { asked = JSON.parse(text); } catch (e) { return; }
+      const answer = (status, body) => { if (typeof gateway.onmessage === 'function') gateway.onmessage({ data: JSON.stringify({ id: asked.id, status, body }) }); };
+      const stop = new AbortController();
+      const timer = later(() => stop.abort(), Math.max(1000, Number(asked.timeout) || 240000));
+      ask('/__lamp/ai', { method: 'POST', headers: { 'Content-Type': 'application/json', 'X-Lamp-Page': '1' }, body: JSON.stringify({ path: asked.path, body: asked.body }), signal: stop.signal })
+        .then((r) => r.json()).then((r) => answer(r.status, r.body), () => answer(502, JSON.stringify({ error: 'lamp dev took too long to answer.' })))
+        .finally(() => unlater(timer));
+    };
+    try { Object.defineProperty(window, 'lampGatewayHost', { value: gateway, configurable: true }); } catch (e) {}
+  }
+
+  // MARK: The card on a change
+  // The same card Lamp's app puts on an open app as a change goes in (`LampTransition.Look`, TransitionLook.swift, which
+  // says how it looks: keep the two in step), at the foot of the page: Lamp's mark turning, "Updating" and what's
+  // changing (the words the coding agent gave with `lamp changing`, if it did), then "Updated" for a moment once the
+  // change is on screen, so every change is seen to land. It covers nothing but itself and lets every click through.
+  // The mark turns by the browser's compositor, so it keeps turning while the page is busy with the new code. Never in
+  // a picture lamp takes (`__lampLightHidden`), and still where less motion is asked for.
+  const light = (() => {
+    const HUES = ['#1f8a4a', '#7cbf3a', '#f6b81c', '#f08a1c', '#e2402a', '#d23778'];
+    // As in the Look: the card stays at least this long, "Updated" this long, and the mark turns once in this long.
+    const SHOWN_AT_LEAST = 1.2, HELD_AFTER = 1.4, SPIN_EVERY = 1.4;
+    const still = () => { try { return matchMedia('(prefers-reduced-motion: reduce)').matches; } catch (e) { return false; } };
+    let root = null, card = null, bands = null, title = null, detail = null, spinning = null, shownAt = 0, gone = null, hidden = false, safety = null;
+    // The card's way out ("Updated" fading, or a fade), which a change coming meanwhile stops.
+    let outgoing = null;
+    const make = () => {
+      if (root && root.isConnected) return;
+      root = document.createElement('div');
+      root.setAttribute('aria-hidden', 'true');
+      root.style.cssText = 'position:fixed;inset:0;pointer-events:none;z-index:2147483647;overflow:hidden;contain:strict';
+      card = document.createElement('div');
+      card.style.cssText = 'position:absolute;left:50%;bottom:min(20px,6vh);transform:translateX(-50%);display:flex;align-items:center;gap:8px;' +
+        'height:36px;box-sizing:border-box;padding:0 16px 0 12px;max-width:min(460px,calc(100vw - 32px));border-radius:18px;' +
+        'background:rgba(20,20,20,.86);border:1px solid rgba(255,255,255,.12);box-shadow:0 3px 12px rgba(0,0,0,.3);' +
+        'font:13px/17px -apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;color:#fff;white-space:nowrap;opacity:0';
+      // Lamp's mark: its stripes on their slant, in a disc, which turns while the change is under way.
+      const mark = document.createElement('div');
+      mark.style.cssText = 'flex:none;width:18px;height:18px;border-radius:50%;overflow:hidden;position:relative';
+      bands = document.createElement('div');
+      bands.style.cssText = `position:absolute;left:-5.4px;top:-5.4px;width:28.8px;height:28.8px;transform:rotate(${-30}deg);` +
+        `background:linear-gradient(to bottom, ${HUES.map((hue, i) => `${hue} ${i * 100 / 6}% ${(i + 1) * 100 / 6}%`).join(', ')})`;
+      mark.appendChild(bands);
+      title = document.createElement('span');
+      title.style.cssText = 'flex:none;font-weight:600';
+      detail = document.createElement('span');
+      detail.style.cssText = 'min-width:0;overflow:hidden;text-overflow:ellipsis;opacity:.72';
+      card.append(mark, title, detail);
+      root.appendChild(card);
+      // Beside the body rather than in it: a game running its code again clears what its body held.
+      document.documentElement.appendChild(root);
+      if (hidden) root.style.visibility = 'hidden';
+    };
+    const goAfter = seconds => {
+      unlater(gone);
+      gone = later(() => { spinning = null; root && root.remove(); root = null; shownAt = 0; }, seconds * 1000);
+    };
+    const show = () => {
+      make();
+      unlater(gone);
+      if (outgoing) { outgoing.cancel(); outgoing = null; }
+      if (shownAt) return;
+      shownAt = performance.now();
+      card.animate([{ opacity: 0, transform: still() ? 'translateX(-50%)' : 'translate(-50%, 10px)' }, { opacity: 1, transform: 'translateX(-50%)' }],
+        { duration: 250, easing: 'ease-out', fill: 'forwards' });
+    };
+    const spin = () => {
+      if (still() || spinning) return;
+      spinning = bands.animate([{ transform: 'rotate(-30deg)' }, { transform: 'rotate(330deg)' }], { duration: SPIN_EVERY * 1000, iterations: Infinity });
+    };
+    // Never left over a page that doesn't say its change is on screen (a game stopped by an error): it goes after a
+    // minute, as the card in Lamp's app goes when Lamp stops renewing it.
+    const watch = () => { unlater(safety); safety = later(() => api.fade(), 60000); };
+    let words = '';
+    const api = {
+      // A change came: the card comes up with "Updating", what's changing, and the mark turning.
+      glow(given) {
+        if (typeof given === 'string') words = given;
+        show();
+        watch();
+        title.textContent = 'Updating';
+        detail.textContent = words;
+        spin();
+      },
+      // The game stands still taking it in: the card stays as it is until `reveal`.
+      turn() { api.glow(); },
+      // The change is on screen: "Updated" for a moment, then the card goes.
+      reveal() {
+        if (!root) return;
+        unlater(safety);
+        title.textContent = 'Updated';
+        if (spinning) { spinning.cancel(); spinning = null; }
+        if (!still()) bands.parentNode.animate([{ transform: 'scale(1.25)' }, { transform: 'scale(1)' }], { duration: 300, easing: 'ease-out' });
+        const wait = Math.max(HELD_AFTER, SHOWN_AT_LEAST - (performance.now() - shownAt) / 1000);
+        if (outgoing) outgoing.cancel();
+        outgoing = card.animate([{ opacity: 1 }, { opacity: 0 }], { duration: 300, delay: wait * 1000, fill: 'forwards', easing: 'ease-in-out' });
+        words = '';
+        goAfter(wait + 0.35);
+      },
+      // The change didn't go in now (held for a pause or a Reload): the card goes.
+      fade() {
+        unlater(safety);
+        if (!root) return;
+        if (outgoing) outgoing.cancel();
+        outgoing = card.animate([{ opacity: getComputedStyle(card).opacity }, { opacity: 0 }], { duration: 250, fill: 'forwards' });
+        words = '';
+        goAfter(0.3);
+      },
+      hide(on) { hidden = !!on; if (root) root.style.visibility = on ? 'hidden' : ''; },
+      get words() { return words; },
+    };
+    return api;
+  })();
+  // Left out of the pictures lamp takes of the page.
+  window.__lampLightHidden = on => light.hide(on);
+  // A page opening again for a change goes on saying so until its new code draws, with the same words.
+  const TURNING = 'lamp.dev.turning', WORDS = 'lamp.dev.words';
+  const turnAcross = () => { try { sessionStorage.setItem(TURNING, String(Date.now())); sessionStorage.setItem(WORDS, light.words); } catch (e) {} };
+  try {
+    const since = Number(sessionStorage.getItem(TURNING)), carried = sessionStorage.getItem(WORDS) || '';
+    sessionStorage.removeItem(TURNING);
+    sessionStorage.removeItem(WORDS);
+    if (since && Date.now() - since < 30000) light.glow(carried);
+  } catch (e) {}
+  // How the game said a change went, read for the card: it goes in now, stands still taking it in, waits, or is on screen.
+  const lit = message => {
+    const state = message && message.state;
+    if (state === 'swapped') light.reveal();
+    else if (state === 'rerun') light.turn();
+    else if (state === 'reloading') { light.turn(); turnAcross(); }
+    else if (state === 'held') light.fade();
+    // Once its new frames can show, as Lamp's app reads it (`PageLive`): a game put back where it was says so before its
+    // first frame and its shaders.
+    else if (state === 'shown') light.reveal();
+  };
+
   // What Lamp's app around a page gives it: with these the game runtime knows changes come while it's played, and says
   // how each one went and when the game is past its loading screen.
   const handlers = {
-    lampLive: { postMessage: said }, lampPlaying: { postMessage: state => said({ state: 'page-' + state }) },
+    lampLive: { postMessage: message => { lit(message); said(message); } }, lampPlaying: { postMessage: state => said({ state: 'page-' + state }) },
     // The person played while lamp held the game's controller (`lamp use stick`), and has it back.
     lampDriveTakenOver: { postMessage: why => said({ state: 'taken-over', why: String(why || '') }) },
   };
@@ -41,10 +186,15 @@
     const real = console[level];
     console[level] = (...parts) => { real.apply(console, parts); say(level === 'info' ? 'log' : level, parts); };
   }
+  // Whether the page runs on the game runtime (lamp-game.js), which says so. A game's page without it has `__lampLive`
+  // too (lamp-live.js, given after this script), so that alone doesn't tell; a runtime from before it said so does have
+  // its own `__lampLive`, never lamp-live.js's.
+  const runtime = () => !!window.__lampRuntime || (!!window.__lampLive && !window.__lampLive.lampHelper);
   // A page with the game runtime logs its own errors; any other page's are logged here.
-  addEventListener('error', e => { if (!window.__lampLive) say('error', [e.message + ' (' + (String(e.filename || '').split('/').pop() || 'the page') + ':' + e.lineno + ')']); });
-  addEventListener('unhandledrejection', e => { if (!window.__lampLive) say('error', [String(e.reason && e.reason.message || e.reason)]); });
-  addEventListener('load', () => said({ state: 'page-loaded' }));
+  addEventListener('error', e => { if (!runtime()) say('error', [e.message + ' (' + (String(e.filename || '').split('/').pop() || 'the page') + ':' + e.lineno + ')']); });
+  addEventListener('unhandledrejection', e => { if (!runtime()) say('error', [String(e.reason && e.reason.message || e.reason)]); });
+  // A page without the game runtime is on screen once it has loaded.
+  addEventListener('load', () => { said({ state: 'page-loaded' }); if (!runtime()) light.reveal(); });
 
   // Changes. The line says which change this copy's files had, so one saved while the page was opening comes as soon
   // as the line is open; the browser says the last it heard when the line is opened again after a break.
@@ -62,10 +212,12 @@
   events.addEventListener('hello', e => { if (e.data !== LAMP.run) location.reload(); });
   events.addEventListener('change', e => {
     const change = JSON.parse(e.data);
-    // A game takes the change and keeps the player's place; any other page opens again.
+    light.glow(typeof change.words === 'string' ? change.words : '');
+    // A game takes the change and keeps the player's place (on the runtime, or where lamp-live.js can); any other page
+    // opens again.
     let taken = false;
     try { taken = !!(window.__lampLive && window.__lampLive(change)); } catch (e) {}
-    if (!taken) { said({ gen: change.gen, state: 'reloading' }); location.reload(); }
+    if (!taken) { light.turn(); turnAcross(); said({ gen: change.gen, state: 'reloading' }); location.reload(); }
   });
   events.addEventListener('reload', reopen);
   // With no browser lamp can look into, the page says what's on it itself.
@@ -133,11 +285,11 @@
     // A game drawn on a stage of its own shape, fitted in the window with bars beside or above it: the stage's size.
     // One that fills the window, whatever its shape, has none.
     let stage = null;
-    if (window.__lampLive) {
+    if (runtime()) {
       const canvas = [...document.querySelectorAll('canvas')].map(c => [c, c.getBoundingClientRect()]).sort((a, b) => b[1].width * b[1].height - a[1].width * a[1].height)[0];
       if (canvas && canvas[0].width > 1 && canvas[0].height > 1 && (width - canvas[1].width >= 2 || height - canvas[1].height >= 2)) stage = [canvas[0].width, canvas[0].height];
     }
-    return { tab, stage, title: document.title, path: location.pathname + location.search, width, height, dpr: devicePixelRatio || 1, game: !!window.__lampLive, screen: lines.join('\n') };
+    return { tab, stage, title: document.title, path: location.pathname + location.search, width, height, dpr: devicePixelRatio || 1, game: runtime(), screen: lines.join('\n') };
   };
 
   // The point of the control called this in the screen as text (`button "Add"`, or just `Add`), for a click by name.

package/cli/share.mjs

@@ -5,25 +5,46 @@
 // The link's secret, which is what lets it be changed or taken down, is kept with lamp's own state for the folder,
 // never in the folder: a folder is committed and published, and the secret is whoever shared it's alone.
 
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
 import { deflateRawSync } from "node:zlib";
-import { Problem, stateOf } from "./state.mjs";
+import { NOTES_FILE, Problem, stateOf } from "./state.mjs";
 import { ANY_BROWSER, CONTROLLERS, CONTROLLERS_FILE, DEVICE_FILE, lampJS, LIBRARIES } from "./dev.mjs";
 import { LIMITS, FILE_LIMITS, PAGE_LIMITS } from "../site/lib/shared-wishes.js";
-import { ideasOf, publishLink, removeFile, removeIdea, removeLink, sendFile, siteOrigin } from "./link.mjs";
+import { ideasOf, makerOf, pageUp, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile, siteOrigin } from "./link.mjs";
 import { exportApp } from "./lampapp.mjs";
 
 export { siteOrigin };
 
 const linkFileOf = (folder) => join(stateOf(folder), "link.json");
 
+
+/**
+ * The maker's account on a site, as lamp keeps it (`lamp account`): `{ username, key }`, the key sent with every share
+ * so a link goes under the username (lamp.dev/<username>/<app>). Kept with lamp's state, never in a folder.
+ */
+const accountsFile = () => join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "account.json");
+export function accountFor(site = siteOrigin()) {
+  try { const kept = JSON.parse(readFileSync(accountsFile(), "utf8"))[site]; return kept?.key ? kept : null; } catch { return null; }
+}
+export function keepAccount(site, account) {
+  let all = {};
+  try { all = JSON.parse(readFileSync(accountsFile(), "utf8")) || {}; } catch {}
+  all[site] = account;
+  mkdirSync(dirname(accountsFile()), { recursive: true });
+  writeFileSync(accountsFile(), JSON.stringify(all, null, 2), { mode: 0o600 });
+}
+
 /** The folder's link, as it was last shared: its address, its secret and the words it went out with. */
 export function readLink(folder) {
   try { return JSON.parse(readFileSync(linkFileOf(folder), "utf8")); } catch { return null; }
 }
-function writeLink(folder, link) {
+/** Forgets the folder's link here, leaving it on the site (one Lamp's app let go of, say). */
+export function forgetLink(folder) { rmSync(linkFileOf(folder), { force: true }); }
+export function writeLink(folder, link) {
   mkdirSync(stateOf(folder), { recursive: true });
   writeFileSync(linkFileOf(folder), JSON.stringify(link, null, 2), { mode: 0o600 });
 }
@@ -83,7 +104,7 @@ export function pageFiles(layout, { device = ANY_BROWSER } = {}) {
   const walk = (dir, prefix) => {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const path = prefix + entry.name;
-      if (entry.name.startsWith(".") || entry.name === "node_modules" || path === "APP.md") continue;
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || path === NOTES_FILE) continue;
       if (entry.isDirectory()) walk(join(dir, entry.name), path + "/");
       else if (entry.isFile()) files.set(path, readFileSync(join(dir, entry.name)));
     }
@@ -118,6 +139,33 @@ export function pageFiles(layout, { device = ANY_BROWSER } = {}) {
 
 // MARK: The site
 
+/** The repository a git remote's address names on GitHub, as "owner/name", or null for any other place. */
+export function githubRepoOf(remote) {
+  const found = /^(?:https:\/\/(?:[^@/]+@)?github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([A-Za-z0-9-]{1,39})\/([A-Za-z0-9._-]{1,100}?)(?:\.git)?\/?$/.exec(String(remote ?? "").trim());
+  return found && found[2] !== "." && found[2] !== ".." ? `${found[1]}/${found[2]}` : null;
+}
+
+/**
+ * The folder's repository on GitHub, for its link's page to point to: only when the folder is the top of a git
+ * checkout whose origin is on GitHub, and GitHub, asked with no sign-in, says anyone can read it. Null otherwise, and
+ * when git or GitHub can't answer, so nothing is linked that might not be public.
+ */
+export async function publicRepoOf(folder) {
+  let top, remote;
+  try {
+    top = execFileSync("git", ["-C", folder, "rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    remote = execFileSync("git", ["-C", folder, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch { return null; }
+  if (resolve(top) !== resolve(folder)) return null;
+  const repo = githubRepoOf(remote);
+  if (!repo) return null;
+  try {
+    const answer = await fetch(`https://api.github.com/repos/${repo}`, { headers: { accept: "application/vnd.github+json" }, signal: AbortSignal.timeout(6000) });
+    if (!answer.ok) return null;
+    return (await answer.json())?.private === false ? repo : null;
+  } catch { return null; }
+}
+
 const megabytes = (bytes) => `${(bytes / 1_000_000).toFixed(bytes < 10_000_000 ? 1 : 0)} MB`;
 
 /**
@@ -125,7 +173,7 @@ const megabytes = (bytes) => `${(bytes / 1_000_000).toFixed(bytes < 10_000_000 ?
  * are what the link says (`name`, `words`, and `line`, `by` and `asks` when given), `picture` a PNG or JPEG of the
  * page or null, `shape` "fill" or the page's width over its height. Answers the link and what went up.
  */
-export async function share({ layout, words, picture = null, shape = "fill", site = siteOrigin(), said = () => {}, file = true, anyway = false }) {
+export async function share({ layout, words, picture = null, shape = "fill", site = siteOrigin(), said = () => {}, file = true, anyway = false, github, fromLamp = false }) {
   // The app's own file goes with the link, as Lamp's Share Link sends it, so whoever follows the link can open it in
   // Lamp too: made first, with Share…'s checks, so a page that can't be shared (a key in it) puts nothing up.
   const app = file ? exportApp(layout.folder, { anyway }) : null;
@@ -137,17 +185,22 @@ export async function share({ layout, words, picture = null, shape = "fill", sit
   const zip = zipOf(files);
   if (zip.length > FILE_LIMITS.total) throw new Problem(`the page is ${megabytes(zip.length)} packed, and a link carries ${megabytes(FILE_LIMITS.total)} at most`);
   if (picture && picture.length > LIMITS.picture) picture = null;
+  // The page links to the folder's public repository on GitHub, when it's one (`github` given in its place by a test).
+  const repo = github === undefined ? await publicRepoOf(layout.folder) : github;
 
   const body = {
     name: words.name, words: words.words, shape,
     ...(words.line ? { line: words.line } : {}), ...(words.by ? { by: words.by } : {}),
     ...(words.asks?.length ? { asks: words.asks } : {}), ...(picture ? { picture: picture.toString("base64") } : {}),
+    ...(repo ? { github: repo } : {}),
   };
   // The folder's own link when it has one on this site, changed in place; a link that's gone is made again.
   let earlier = readLink(layout.folder);
   if (earlier && earlier.site !== site) earlier = null;
   // A file an earlier share sent stays on the record until it's taken away, so a retry after a failed removal tries again.
-  let link = { site, ...(await publishLink({ site, body, earlier })), ...words, shape, ...(earlier?.file ? { file: true } : {}) };
+  // A link that's a Lamp's (`fromLamp`, the app in its own folder) stays so in every write, a share that fails partway too.
+  let link = { site, ...(await publishLink({ site, body, earlier, account: accountFor(site)?.key })), ...words, shape, ...(earlier?.file ? { file: true } : {}),
+    ...(fromLamp ? { fromLamp: true } : {}) };
   // Kept before the page goes up: a link whose page didn't make it is still this folder's to send again or take down.
   writeLink(layout.folder, link);
 
@@ -164,7 +217,8 @@ export async function share({ layout, words, picture = null, shape = "fill", sit
   const version = await sendFile({ site, link, bytes: zip, page: true, said });
   link = { ...link, version, shared: new Date().toISOString() };
   writeLink(layout.folder, link);
-  return { url: link.url, version, files: files.length, bytes: zip.length, picture: !!picture, file: !!app };
+  await pageUp({ site, id: link.id, version, said });
+  return { url: link.url, version, files: files.length, bytes: zip.length, picture: !!picture, file: !!app, github: repo || null };
 }
 
 /** Takes the folder's link down, with its page and the ideas sent to it. */
@@ -177,17 +231,31 @@ export async function unshare(folder) {
 }
 
 /** The ideas people playing the link have sent its maker and that are still open: each with its number. */
-export async function ideas(folder) {
+export async function ideas(folder, { earlier = false } = {}) {
   const link = readLink(folder);
   if (!link) throw new Problem("this folder has no link: lamp share makes one");
-  return { url: link.url, ideas: await ideasOf({ site: link.site, link }) };
+  return { url: link.url, ideas: await ideasOf({ site: link.site, link, earlier }) };
 }
 
 /** Says what became of an idea: it's in (the site writes to whoever asked to hear), or it's let go. */
-export async function finishIdea(folder, n, built) {
+export async function finishIdea(folder, n, built, note) {
   const link = readLink(folder);
   if (!link) throw new Problem("this folder has no link");
-  return removeIdea({ site: link.site, link, n, built });
+  return removeIdea({ site: link.site, link, n, built, note });
+}
+
+/** Says something more about an idea to whoever sent it; with no note, that their answer is seen to. */
+export async function answerIdea(folder, n, note) {
+  const link = readLink(folder);
+  if (!link) throw new Problem("this folder has no link");
+  return replyIdea({ site: link.site, link, n, note });
+}
+
+/** The maker's own address for the link's ideas, or, with `email`, given ("" takes it away). */
+export async function makerEmail(folder, email) {
+  const link = readLink(folder);
+  if (!link) throw new Problem("this folder has no link: lamp share makes one");
+  return makerOf({ site: link.site, link, email });
 }
 
 /** The page's name where nothing gave one: its title, or its folder's name. */