@lampdotdev/lamp 0.36.2-nightly.17 → 0.36.2-nightly.21

package/README.md

@@ -33,7 +33,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp unshare` | Takes the link down. |
 | `lamp account [username] [--email address]` | The maker's account on lamp.dev, which their links go under (`lamp.dev/<username>/<app>`): with a username and an email it asks the site for one (`askAccount`), whose key lamp keeps with its state (`account.json`, by site) and sends with every share (`X-Lamp-Account`); the link in the email the site sends confirms it. With only an email that has an account, it signs in to it, with a key of its own. On its own, it says which it's signed in as. A share before the email's link is opened goes out as links always have (`/w/<id>-<name>`), and moves under the username at its next share. |
 | `lamp play <link> [--to folder] [--newest]` | Plays an app shared on lamp.dev on this computer: the link's file (`latestOf`, its `.lampapp`), unpacked as `lamp unpack` does into a folder of its own in `~/Lamp Games` (or `--to`), with Lamp's own files beside its page, then opened as `lamp open` opens any folder. Its AI is answered by `lamp dev` (`ai.mjs`) in any browser, Safari included, where a shared page can't reach the computer. lamp remembers which folder each link went into (a file for each link under `played/` in its state), so playing it again goes on where it was; `--newest` takes the link's latest version into a new folder. |
-| `lamp ai [--forget]` | Answers the AI of pages shared on lamp.dev, played in a browser on this computer, with the person's own Claude Code, Codex or OpenRouter key (`cli/local-ai.mjs`, the same answers as `ai.mjs` gives `lamp dev`), until it's stopped. It listens on this computer alone at a port lamp.js knows (`LOCAL_AI_PORT`, `NEARBY` in lamp.js), and answers only a link's own page (`<id in hex>.play.lamp.dev`, `playOrigin`): the first time a page uses the AI, the person is asked in the terminal, and the page keeps the token it's given. Whether there's an AI is answered without asking. The browser asks the person too, once, before a page may reach this computer, so the link's frame on lamp.dev is given that permission. Safari never lets the page reach it (Safari 27, checked against a stand-in on the port), so lamp.js tells someone playing in Safari to use Chrome, Lamp or `lamp play` instead. `--forget` takes back every page allowed. Lamp's app runs the same server while it's open (`sharedPages` in `calls.mjs`, `SharedPagesAI`): it asks the person in a dialog and answers with the AI they set up in Lamp, and the pages allowed are the same list; whichever of the two starts first answers. |
+| `lamp ai [--forget]` | Answers the AI of pages shared on lamp.dev, played in a browser on this computer, with the person's own Claude Code, Codex or OpenRouter key (`cli/local-ai.mjs`, the same answers as `ai.mjs` gives `lamp dev`), until it's stopped. It listens on this computer alone at a port lamp.js knows (`LOCAL_AI_PORT`, `NEARBY` in lamp.js), and answers only a link's own page (`<id in hex>.play.lamp.dev`, `playOrigin`): the first time a page uses the AI, the person is asked in the terminal, and the page keeps the token it's given. Whether there's an AI is answered without asking. The browser asks the person too, once, before a page may reach this computer, so the link's frame on lamp.dev is given that permission; lamp.js reaches the port only once that's granted, the page has a token, or the person asks (`LampAI.connect()` from a button, or a real AI call), so the browser doesn't ask as the page loads. Safari never lets the page reach it (Safari 27, checked against a stand-in on the port), so lamp.js tells someone playing in Safari to use Chrome, Lamp or `lamp play` instead. `--forget` takes back every page allowed. Lamp's app runs the same server while it's open (`sharedPages` in `calls.mjs`, `SharedPagesAI`): it asks the person in a dialog and answers with the AI they set up in Lamp, and the pages allowed are the same list; whichever of the two starts first answers. |
 | `lamp devices [add \| forget <name>]` | The person's devices lamp puts a page on: an Xbox in Developer Mode (those set up and those found on the network), and Android (lamp's emulators, and the phones, tablets and TVs plugged in with USB debugging on). `add` sets one up, a step at a time; `add android` downloads Android's tools. |
 | `lamp open --on xbox` | Packages the page, installs it on the device and opens it there. `lamp look --on xbox` is the device's screen and the app's log there, `lamp stop --on xbox` ends it, and `lamp remove --on xbox` takes it off. |
 | `lamp open --on android [--hidden]` | Builds Lamp's Android app around the page and opens it in lamp's Android emulator (`--on android-tv`: its TV emulator; a device of the person's by its name), with `look`, `stop` and `remove` as on any device, and `lamp use --on android` to tap, type and press there. `--hidden` starts the emulator with no window. |
@@ -222,7 +222,10 @@ of the link's own.
   errors isn't shared without `--anyway`.
 - **The link's secret**, which is what lets it be changed or taken down, is kept with lamp's state for the folder
   (`link.json`, readable only by the person), never in the folder.
-- **Not sent:** the wish's own file, which only Lamp's app makes. The link plays the page and carries its words.
+- **The app's file** goes too (`exportApp`, as `lamp export` makes it), as Lamp's Share Link card sends it, unless
+  `--no-file`. Its own place on its credits' chain names the link it went up with (`link`, `lamp.dev/w/<id>`).
+- **Where it came from:** a copy of an app someone shared (`lamp play`, `lamp unpack`) has their link on its chain, so
+  its own share names that link (`from`, `sourceLinkOf`), and its page says "from" them.
 - **`LAMP_SITE`** names another site to share to, for trying this against a copy of the site (`npm run dev` in
   `site/` keeps links in memory). The tests run against the site's handlers the same way, and never reach lamp.dev.
 

package/Resources/skills/app-ai/SKILL.md

@@ -86,7 +86,7 @@ else { status = result.summary }
 ```
 
 - Show the feature where `await LampAI.status(.act)` says it's available, with what answers and where its `processing`
-  is (`remote` for a service, Claude Code and Codex included; `onDevice` for a model on this Mac). When it isn't, keep
+  is (`remote` for a service, Claude Code and Codex included). When it isn't, keep
   the feature visible with its `reason` and a "Set up in Lamp" button (`LampAI.openSetup(for: .act)`), or "Open Lamp" /
   "Update Lamp" when `setup` says so; keep the typed draft, and every manual control working. Check again when the app
   comes back to the front, and never send the draft by itself after setup. Available is no guarantee: show the actual

package/Resources/skills/web-app/SKILL.md

@@ -20,7 +20,10 @@ opening comment for the whole list. What it gives:
   on it, check `LampAI.status('text')` and, when it can't answer, show its `reason` as it's given: lamp.js words it
   for where the page is (away from the Mac's Wi‑Fi, Lamp closed, a link on lamp.dev), so don't write your own. Where it
   gives `help` (a page away from Lamp), add a link to it beside the reason, "How to turn on AI", so someone who has never
-  heard of Lamp finds out how.
+  heard of Lamp finds out how. Where it answers `connect: true` (a page on lamp.dev that hasn't reached this computer
+  yet), also show a small "Connect AI" button that calls `LampAI.connect(capability)` with the same kind of AI you asked
+  `status` about (`LampAI.connect('pictures')` for pictures) and use the answer it gives as `status`'s;
+  never call `connect()` as the page loads, since it makes the browser ask the person.
 - **LampAI.act**: the person asks the app to do something in their own words, and the app's own reads and writes do
   it; "Doing things for the person" below, with **LampVoice** and **LampAI.hear** for saying it.
 - **LampStore**: what the app saves, as JSON on the device. Once something is saved, only ever add to it: a new field

package/THIRD_PARTY_NOTICES.md

@@ -28,32 +28,6 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
-## llama.cpp
-
-https://github.com/ggml-org/llama.cpp (llama-server and its libraries)
-
-MIT License
-
-Copyright (c) 2023-2026 The ggml authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
 ## Lobe Icons
 
 https://github.com/lobehub/lobe-icons (`@lobehub/icons-static-png`, the provider logos in Settings)

package/cli/app-ai.mjs

@@ -11,8 +11,8 @@
 // page's.
 //
 // Every route is asked one of two ways and read into the same calls-or-reply: a chat with OpenAI-style tools
-// (OpenRouter, an MLX model whose server takes tools: `chatBody`, `readMessage`), or one prompt whose answer must fit
-// the step's JSON shape (Claude Code, Codex, a GGUF model, an older MLX model: `planPrompt`, `planSchema`, `readPlan`).
+// (OpenRouter: `chatBody`, `readMessage`), or one prompt whose answer must fit the step's JSON shape (Claude Code, Codex:
+// `planPrompt`, `planSchema`, `readPlan`).
 
 export const MAX_TOOLS = 24, MAX_CALLS = 8, MAX_STEPS = 4, MAX_BODY = 256 * 1024, MAX_CHOICES = 4, MAX_CHOICE = 24;
 /** The longest a step may take, whatever its route, before its call is taken to have stopped answering (`ACT_STEP_SECONDS`
@@ -320,8 +320,8 @@ function framing(r, tag) {
 }
 
 /**
- * An OpenAI-style chat with tools, Lamp's `reply` among them, for OpenRouter and an MLX model's server. With `model`,
- * it's OpenRouter's request: `require_parameters` keeps OpenRouter on providers that take tools and `tool_choice` as
+ * An OpenAI-style chat with tools, Lamp's `reply` among them, for OpenRouter, whose `model` it names:
+ * `require_parameters` keeps OpenRouter on providers that take tools and `tool_choice` as
  * given, and the models offered for apps' text take only "auto" and "none" there, so an answer may also be words without
  * a call, which is the reply; a step asked for a reply only says "none".
  */
@@ -369,15 +369,13 @@ export function planSchema(r) {
 
 /**
  * The step as one prompt, for a route that takes text and answers in `planSchema`'s shape: the tools described, then the
- * turn so far, every earlier call and its result fenced as outside text. `schemaInPrompt` says the shape in words too,
- * for a model nothing holds to it.
+ * turn so far, every earlier call and its result fenced as outside text.
  */
-export function planPrompt(r, tag, retry, schemaInPrompt = false) {
+export function planPrompt(r, tag, retry) {
   let { system, user: prompt } = framing(r, tag);
   system += "\n\n" + PLAN;
   if (r.final) system += '\nOnly a reply is possible now: answer {"reply": {...}}.';
   else system += "\n\nThe app's tools:\n" + r.tools.map((tool) => `- ${tool.name}: ${tool.reads ? "Looks up, changes nothing. " : "Changes the app's data. "}${tool.about}\n  Arguments: ${json(toolSchema(tool))}`).join("\n");
-  if (schemaInPrompt) system += "\n\nThe JSON Schema your answer must fit:\n" + json(planSchema(r));
   r.steps.forEach((step, i) => {
     prompt += `\n\nYour answer ${i + 1} called:\n` + json(step.calls.map((c) => ({ name: c.name, args: c.args })));
     prompt += "\nWhat happened, in that order:\n" + fence(tag, json(step.calls.map((c) => ({ ...(step.results[c.id] ?? skipped), name: c.name }))));

package/cli/calls.mjs

@@ -423,12 +423,12 @@ export const CALLS = {
 
   /**
    * 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.
+   * and "plan" one prompt held to the step's shape (`{system, prompt, schema}`).
    */
   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) };
+    return { ...planPrompt(step, tag, retry), schema: planSchema(step) };
   },
 
   /** A step's answer read and checked: `message` from a chat with tools, or `plan`'s text. `{answer}` or `{problem}`. */

package/cli/lampapp.mjs

@@ -8,6 +8,7 @@ import { basename, dirname, join, resolve, sep } from "node:path";
 import { inflateRawSync } from "node:zlib";
 import { Problem, RESOURCES, manifestOf, projectOf, stateOf } from "./state.mjs";
 import { LIMITS, nameOf, zipOf } from "./share.mjs";
+import { isID } from "../site/lib/shared-wishes.js";
 
 // 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.
@@ -214,9 +215,10 @@ function identityOf(folder) {
  * and lamp-app.json, which says what it is. Never Lamp's own files, which the Mac that opens it writes, nor anything
  * hidden. Refused when a license its credits name is gone, when something in it is shaped like a key, or when it's
  * more than another Lamp opens. Work its credits give no license for goes only with `anyway`: its author may not want
- * it passed on.
+ * it passed on. `link` is the lamp.dev link the file goes up with (`share`), which this app's place in the chain carries,
+ * so a copy of it shared on can say which link it came from (`sourceLinkOf`).
  */
-export function exportApp(given, { anyway = false } = {}) {
+export function exportApp(given, { anyway = false, link = null } = {}) {
   const project = projectOf(given), folder = project.folder, manifest = manifestOf(folder);
   // Where the app's own record is (its credits, licenses, notes, files and the Swift beside its page): the folder, or
   // for a site laid out as Lamp puts one on GitHub, `.lamp-wish/` beside the page (`StaticSite.layOut`).
@@ -291,7 +293,7 @@ export function exportApp(given, { anyway = false } = {}) {
 
   // Whoever opens the file is remixing this app: it's added to the chain its credits carry, as one link if it's
   // already the last (`Credits.remixed`).
-  const me = { name, wish: identityOf(folder) }, chain = Array.isArray(credits?.remixOf) ? credits.remixOf.filter((link) => link && typeof link.name === "string") : [];
+  const me = { name, wish: identityOf(folder), ...(link ? { link } : {}) }, chain = Array.isArray(credits?.remixOf) ? credits.remixOf.filter((link) => link && typeof link.name === "string") : [];
   const last = chain.at(-1);
   if (last && (last.wish ? last.wish === me.wish : !last.starter && last.name === me.name)) chain[chain.length - 1] = { ...last, ...me, url: last.url, commit: last.commit };
   else chain.push(me);
@@ -324,6 +326,28 @@ export function exportApp(given, { anyway = false } = {}) {
   return { name, kind, bytes, files: files.size };
 }
 
+/**
+ * The id of the link on `site` that the app in the folder came from, for a share to name (`from`): the last app in its
+ * credits' chain that went up with a link there (`exportApp`'s `link`), other than `own`, the folder's own link. Null for
+ * an app that came from no link. An unpacked copy keeps the app's identity, so its first share replaces that entry's
+ * link in the file it sends; the folder's own credits still name the one it came from.
+ */
+export function sourceLinkOf(folder, site, own = null) {
+  const app = existsSync(join(folder, ".lamp-wish", "lamp-app.json")) ? join(folder, ".lamp-wish") : folder;
+  let chain;
+  try { chain = JSON.parse(readFileSync(join(app, "credits.json"), "utf8"))?.remixOf; } catch { return null; }
+  if (!Array.isArray(chain)) return null;
+  let origin;
+  try { origin = new URL(site).origin; } catch { return null; }
+  for (const entry of [...chain].reverse()) {
+    let url;
+    try { url = new URL(entry?.link); } catch { continue; }
+    const id = /^\/w\/([^/]+)$/.exec(url.pathname)?.[1];
+    if (url.origin === origin && isID(id) && id !== own) return id;
+  }
+  return null;
+}
+
 /** An object with its keys in order, at every level, as Lamp's own encoder writes its files. */
 function sortedKeys(value) {
   if (Array.isArray(value)) return value.map(sortedKeys);

package/cli/lamps/lamp-for-games.js

@@ -254,6 +254,26 @@
     var ua = (window.navigator && navigator.userAgent) || '';
     return /Safari\//.test(ua) && !/Chrome|Chromium|CriOS|Edg|OPR|Firefox|FxiOS/.test(ua);
   }
+  var SAFARI_AI = 'AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.';
+
+  // Reaching this computer makes the browser ask the person about it, so a shared page doesn't reach out just to
+  // see whether there's an AI: only once the browser already lets it, the page has paired before, or the person
+  // has asked for it (LampAI.connect, from a button, or a real AI call).
+  var nearbyAsked = false;
+  function nearbyAllowed() {
+    // Connected before in this browser (kept with the page's saved things): the browser has had its say already.
+    if (nearbyAsked || read('nearby.token', null) || read('nearby.connected', false)) return Promise.resolve(true);
+    var permissions = window.navigator && navigator.permissions;
+    if (!permissions || typeof permissions.query !== 'function') return Promise.resolve(false);
+    // Chrome has named this permission more than one way; any that's granted will do, and one it doesn't know is unknown.
+    var names = ['local-network-access', 'loopback-network', 'local-network'];
+    return Promise.all(names.map(function (name) {
+      try {
+        return Promise.resolve(permissions.query({ name: name })).then(function (s) { return !!s && s.state === 'granted'; }, function () { return false; });
+      } catch (e) { return false; }
+    })).then(function (states) { return states.indexOf(true) !== -1; });
+  }
+
   function nearby(path, body, timeout, deadline) {
     var text = JSON.stringify(body);
     function go(t) { return exchange(NEARBY, path, t, text, deadline ? Math.max(1000, deadline - Date.now()) : timeout); }
@@ -276,7 +296,7 @@
     return done.then(null, function (e) {
       if (e instanceof Failure) throw e;
       // Safari never lets a page on the web reach this computer this way, so Lamp or lamp ai open here wouldn't help.
-      if (safari()) throw new Failure('AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.', null, AI_HELP);
+      if (safari()) throw new Failure(SAFARI_AI, null, AI_HELP);
       throw new Failure('AI isn\'t available here. Open Lamp on this computer, or with Lamp\'s command line, run lamp ai.', null, AI_HELP);
     });
   }
@@ -738,31 +758,58 @@
    * a feature depends on it, and show the feature with its `reason` as it's given rather than words of the app's
    * own, or hiding it or failing at it, and where it gives `help` (a page away from Lamp), a link to it beside the
    * reason: "How to turn on AI". A call that fails for that reason has `needsSetup`, or `help`, set on its error.
+   * On a page shared on lamp.dev that hasn't reached this computer yet, `status` asks nothing and answers
+   * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
+   * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
+   * call `connect()` as the page loads.
    */
   var LampAI = {
     Failure: Failure,
 
     /** Whether this kind of AI ('text', 'decisions', 'pictures', 'act' or 'hear') can answer now: { available, reason,
-     *  help }, where `reason` is the short line to show when it can't, written for where the page is, and `help`, when
-     *  it's there, the page that says how to turn AI on, to link to beside it. */
+     *  help, connect }, where `reason` is the short line to show when it can't, written for where the page is, `help`,
+     *  when it's there, the page that says how to turn AI on, to link to beside it, and `connect`, when true, that
+     *  a button calling `LampAI.connect()` would find out (a page on lamp.dev, before it has reached this computer). */
     status: function (capability) {
       var no = function (reason, help) {
         var said = { available: false, reason: reason || 'AI isn\'t set up for this here.' };
         if (help) said.help = help;
         return said;
       };
-      // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
-      // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
-      if (capability === 'act' || capability === 'hear') {
-        return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
-          return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return ask(capability);
+          if (safari()) return no(SAFARI_AI, AI_HELP);
+          return { available: false, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return ask(capability);
+      function ask(capability) {
+        // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
+        // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
+        if (capability === 'act' || capability === 'hear') {
+          return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
+            return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+          }, function (e) { return no(e && e.message, e && e.help); });
+        }
+        return post('/ai/status', {}, 10000).then(function (reply) {
+          if (reply[capability] === true) return { available: true, reason: '' };
+          var detail = reply.details && reply.details[capability];
+          return no(detail && detail.reason);
         }, function (e) { return no(e && e.message, e && e.help); });
       }
-      return post('/ai/status', {}, 10000).then(function (reply) {
-        if (reply[capability] === true) return { available: true, reason: '' };
-        var detail = reply.details && reply.details[capability];
-        return no(detail && detail.reason);
-      }, function (e) { return no(e && e.message, e && e.help); });
+    },
+
+    /** On a page shared on lamp.dev, reaches the AI on this computer, so the browser asks the person then: call it
+     *  from a button ("Connect AI") shown when `status` answers `connect: true`, never as the page loads. Gives what
+     *  `status` gives for that kind of AI ('text' unless named). Anywhere else it's just `status`. */
+    connect: function (capability) {
+      nearbyAsked = true;
+      return LampAI.status(capability || 'text').then(function (said) {
+        // Reached it (whatever it said of this kind of AI): later visits look without asking first.
+        if (said.available || !said.help) write('nearby.connected', true);
+        return said;
+      });
     },
 
     /** Whether this kind of AI can answer now, as `status` says. */

package/cli/lamps/lamp.js

@@ -254,6 +254,26 @@
     var ua = (window.navigator && navigator.userAgent) || '';
     return /Safari\//.test(ua) && !/Chrome|Chromium|CriOS|Edg|OPR|Firefox|FxiOS/.test(ua);
   }
+  var SAFARI_AI = 'AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.';
+
+  // Reaching this computer makes the browser ask the person about it, so a shared page doesn't reach out just to
+  // see whether there's an AI: only once the browser already lets it, the page has paired before, or the person
+  // has asked for it (LampAI.connect, from a button, or a real AI call).
+  var nearbyAsked = false;
+  function nearbyAllowed() {
+    // Connected before in this browser (kept with the page's saved things): the browser has had its say already.
+    if (nearbyAsked || read('nearby.token', null) || read('nearby.connected', false)) return Promise.resolve(true);
+    var permissions = window.navigator && navigator.permissions;
+    if (!permissions || typeof permissions.query !== 'function') return Promise.resolve(false);
+    // Chrome has named this permission more than one way; any that's granted will do, and one it doesn't know is unknown.
+    var names = ['local-network-access', 'loopback-network', 'local-network'];
+    return Promise.all(names.map(function (name) {
+      try {
+        return Promise.resolve(permissions.query({ name: name })).then(function (s) { return !!s && s.state === 'granted'; }, function () { return false; });
+      } catch (e) { return false; }
+    })).then(function (states) { return states.indexOf(true) !== -1; });
+  }
+
   function nearby(path, body, timeout, deadline) {
     var text = JSON.stringify(body);
     function go(t) { return exchange(NEARBY, path, t, text, deadline ? Math.max(1000, deadline - Date.now()) : timeout); }
@@ -276,7 +296,7 @@
     return done.then(null, function (e) {
       if (e instanceof Failure) throw e;
       // Safari never lets a page on the web reach this computer this way, so Lamp or lamp ai open here wouldn't help.
-      if (safari()) throw new Failure('AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.', null, AI_HELP);
+      if (safari()) throw new Failure(SAFARI_AI, null, AI_HELP);
       throw new Failure('AI isn\'t available here. Open Lamp on this computer, or with Lamp\'s command line, run lamp ai.', null, AI_HELP);
     });
   }
@@ -738,31 +758,58 @@
    * a feature depends on it, and show the feature with its `reason` as it's given rather than words of the app's
    * own, or hiding it or failing at it, and where it gives `help` (a page away from Lamp), a link to it beside the
    * reason: "How to turn on AI". A call that fails for that reason has `needsSetup`, or `help`, set on its error.
+   * On a page shared on lamp.dev that hasn't reached this computer yet, `status` asks nothing and answers
+   * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
+   * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
+   * call `connect()` as the page loads.
    */
   var LampAI = {
     Failure: Failure,
 
     /** Whether this kind of AI ('text', 'decisions', 'pictures', 'act' or 'hear') can answer now: { available, reason,
-     *  help }, where `reason` is the short line to show when it can't, written for where the page is, and `help`, when
-     *  it's there, the page that says how to turn AI on, to link to beside it. */
+     *  help, connect }, where `reason` is the short line to show when it can't, written for where the page is, `help`,
+     *  when it's there, the page that says how to turn AI on, to link to beside it, and `connect`, when true, that
+     *  a button calling `LampAI.connect()` would find out (a page on lamp.dev, before it has reached this computer). */
     status: function (capability) {
       var no = function (reason, help) {
         var said = { available: false, reason: reason || 'AI isn\'t set up for this here.' };
         if (help) said.help = help;
         return said;
       };
-      // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
-      // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
-      if (capability === 'act' || capability === 'hear') {
-        return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
-          return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return ask(capability);
+          if (safari()) return no(SAFARI_AI, AI_HELP);
+          return { available: false, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return ask(capability);
+      function ask(capability) {
+        // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
+        // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
+        if (capability === 'act' || capability === 'hear') {
+          return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
+            return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+          }, function (e) { return no(e && e.message, e && e.help); });
+        }
+        return post('/ai/status', {}, 10000).then(function (reply) {
+          if (reply[capability] === true) return { available: true, reason: '' };
+          var detail = reply.details && reply.details[capability];
+          return no(detail && detail.reason);
         }, function (e) { return no(e && e.message, e && e.help); });
       }
-      return post('/ai/status', {}, 10000).then(function (reply) {
-        if (reply[capability] === true) return { available: true, reason: '' };
-        var detail = reply.details && reply.details[capability];
-        return no(detail && detail.reason);
-      }, function (e) { return no(e && e.message, e && e.help); });
+    },
+
+    /** On a page shared on lamp.dev, reaches the AI on this computer, so the browser asks the person then: call it
+     *  from a button ("Connect AI") shown when `status` answers `connect: true`, never as the page loads. Gives what
+     *  `status` gives for that kind of AI ('text' unless named). Anywhere else it's just `status`. */
+    connect: function (capability) {
+      nearbyAsked = true;
+      return LampAI.status(capability || 'text').then(function (said) {
+        // Reached it (whatever it said of this kind of AI): later visits look without asking first.
+        if (said.available || !said.help) write('nearby.connected', true);
+        return said;
+      });
     },
 
     /** Whether this kind of AI can answer now, as `status` says. */

package/cli/lamps/mac-starter/.lamp/meta.json

@@ -1 +1 @@
-{"exe":"ZqxAppName","platform":"mac","name":"Zqx App Name","instance":"1DF88C4D-5D7E-40DA-8372-9DF474A63D4E"}
+{"exe":"ZqxAppName","name":"Zqx App Name","instance":"66001C8E-04AF-4B31-9585-64F312C02625","platform":"mac"}

package/cli/lamps/web-starter/lamp.js

@@ -254,6 +254,26 @@
     var ua = (window.navigator && navigator.userAgent) || '';
     return /Safari\//.test(ua) && !/Chrome|Chromium|CriOS|Edg|OPR|Firefox|FxiOS/.test(ua);
   }
+  var SAFARI_AI = 'AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.';
+
+  // Reaching this computer makes the browser ask the person about it, so a shared page doesn't reach out just to
+  // see whether there's an AI: only once the browser already lets it, the page has paired before, or the person
+  // has asked for it (LampAI.connect, from a button, or a real AI call).
+  var nearbyAsked = false;
+  function nearbyAllowed() {
+    // Connected before in this browser (kept with the page's saved things): the browser has had its say already.
+    if (nearbyAsked || read('nearby.token', null) || read('nearby.connected', false)) return Promise.resolve(true);
+    var permissions = window.navigator && navigator.permissions;
+    if (!permissions || typeof permissions.query !== 'function') return Promise.resolve(false);
+    // Chrome has named this permission more than one way; any that's granted will do, and one it doesn't know is unknown.
+    var names = ['local-network-access', 'loopback-network', 'local-network'];
+    return Promise.all(names.map(function (name) {
+      try {
+        return Promise.resolve(permissions.query({ name: name })).then(function (s) { return !!s && s.state === 'granted'; }, function () { return false; });
+      } catch (e) { return false; }
+    })).then(function (states) { return states.indexOf(true) !== -1; });
+  }
+
   function nearby(path, body, timeout, deadline) {
     var text = JSON.stringify(body);
     function go(t) { return exchange(NEARBY, path, t, text, deadline ? Math.max(1000, deadline - Date.now()) : timeout); }
@@ -276,7 +296,7 @@
     return done.then(null, function (e) {
       if (e instanceof Failure) throw e;
       // Safari never lets a page on the web reach this computer this way, so Lamp or lamp ai open here wouldn't help.
-      if (safari()) throw new Failure('AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.', null, AI_HELP);
+      if (safari()) throw new Failure(SAFARI_AI, null, AI_HELP);
       throw new Failure('AI isn\'t available here. Open Lamp on this computer, or with Lamp\'s command line, run lamp ai.', null, AI_HELP);
     });
   }
@@ -738,31 +758,58 @@
    * a feature depends on it, and show the feature with its `reason` as it's given rather than words of the app's
    * own, or hiding it or failing at it, and where it gives `help` (a page away from Lamp), a link to it beside the
    * reason: "How to turn on AI". A call that fails for that reason has `needsSetup`, or `help`, set on its error.
+   * On a page shared on lamp.dev that hasn't reached this computer yet, `status` asks nothing and answers
+   * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
+   * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
+   * call `connect()` as the page loads.
    */
   var LampAI = {
     Failure: Failure,
 
     /** Whether this kind of AI ('text', 'decisions', 'pictures', 'act' or 'hear') can answer now: { available, reason,
-     *  help }, where `reason` is the short line to show when it can't, written for where the page is, and `help`, when
-     *  it's there, the page that says how to turn AI on, to link to beside it. */
+     *  help, connect }, where `reason` is the short line to show when it can't, written for where the page is, `help`,
+     *  when it's there, the page that says how to turn AI on, to link to beside it, and `connect`, when true, that
+     *  a button calling `LampAI.connect()` would find out (a page on lamp.dev, before it has reached this computer). */
     status: function (capability) {
       var no = function (reason, help) {
         var said = { available: false, reason: reason || 'AI isn\'t set up for this here.' };
         if (help) said.help = help;
         return said;
       };
-      // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
-      // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
-      if (capability === 'act' || capability === 'hear') {
-        return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
-          return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return ask(capability);
+          if (safari()) return no(SAFARI_AI, AI_HELP);
+          return { available: false, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return ask(capability);
+      function ask(capability) {
+        // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
+        // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
+        if (capability === 'act' || capability === 'hear') {
+          return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
+            return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+          }, function (e) { return no(e && e.message, e && e.help); });
+        }
+        return post('/ai/status', {}, 10000).then(function (reply) {
+          if (reply[capability] === true) return { available: true, reason: '' };
+          var detail = reply.details && reply.details[capability];
+          return no(detail && detail.reason);
         }, function (e) { return no(e && e.message, e && e.help); });
       }
-      return post('/ai/status', {}, 10000).then(function (reply) {
-        if (reply[capability] === true) return { available: true, reason: '' };
-        var detail = reply.details && reply.details[capability];
-        return no(detail && detail.reason);
-      }, function (e) { return no(e && e.message, e && e.help); });
+    },
+
+    /** On a page shared on lamp.dev, reaches the AI on this computer, so the browser asks the person then: call it
+     *  from a button ("Connect AI") shown when `status` answers `connect: true`, never as the page loads. Gives what
+     *  `status` gives for that kind of AI ('text' unless named). Anywhere else it's just `status`. */
+    connect: function (capability) {
+      nearbyAsked = true;
+      return LampAI.status(capability || 'text').then(function (said) {
+        // Reached it (whatever it said of this kind of AI): later visits look without asking first.
+        if (said.available || !said.help) write('nearby.connected', true);
+        return said;
+      });
     },
 
     /** Whether this kind of AI can answer now, as `status` says. */

package/cli/share.mjs

@@ -15,11 +15,13 @@ 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, makerOf, pageUp, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile, siteOrigin } from "./link.mjs";
-import { exportApp } from "./lampapp.mjs";
+import { exportApp, sourceLinkOf } from "./lampapp.mjs";
 
 export { siteOrigin };
 
 const linkFileOf = (folder) => join(stateOf(folder), "link.json");
+/** A link by its id alone, which the site sends on to its address now: what a file names, so a rename never breaks it. */
+const stableLink = (site, id) => `${site}/w/${id}`;
 
 
 /**
@@ -174,9 +176,13 @@ const megabytes = (bytes) => `${(bytes / 1_000_000).toFixed(bytes < 10_000_000 ?
  * 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, github, fromLamp = false }) {
+  // 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;
   // 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;
+  // Lamp too: made first, with Share…'s checks, so a page that can't be shared (a key in it) puts nothing up. It names
+  // the link it goes up with, so a copy shared on says it came from this one: made again below if that's a new link.
+  let app = file ? exportApp(layout.folder, { anyway, link: earlier ? stableLink(site, earlier.id) : null }) : null;
   const files = pageFiles(layout);
   const unpacked = files.reduce((total, [, bytes]) => total + bytes.length, 0);
   if (!files.some(([path]) => path === "index.html")) throw new Problem("the page has no index.html at its top");
@@ -194,9 +200,9 @@ export async function share({ layout, words, picture = null, shape = "fill", sit
     ...(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;
+  // The link this app came from, when it's a copy of one shared there: its page says so.
+  const from = sourceLinkOf(layout.folder, site, earlier?.id);
+  if (from) body.from = from;
   // A file an earlier share sent stays on the record until it's taken away, so a retry after a failed removal tries again.
   // 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 } : {}),
@@ -204,6 +210,8 @@ export async function share({ layout, words, picture = null, shape = "fill", sit
   // 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);
 
+  // A new link (or one made again) has its id only now, which the file carries.
+  if (app && link.id !== earlier?.id) app = exportApp(layout.folder, { anyway, link: stableLink(site, link.id) });
   // The file, or none: a link that carried one and shouldn't now has it taken away (and its page with it, sent next).
   if (app) {
     link.file = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lampdotdev/lamp",
-  "version": "0.36.2-nightly.17",
+  "version": "0.36.2-nightly.21",
   "description": "Runs a web app or game from its folder and puts each saved change into the open page.",
   "type": "module",
   "bin": {

package/site/lib/shared-wishes.js

@@ -137,11 +137,11 @@ function release(value) {
 }
 
 /** What a share sends, checked. Null when anything is off. `releases` is undefined when the share didn't say (a Lamp
- *  from before them), so a change keeps the ones the link has. */
+ *  from before them), so a change keeps the ones the link has; `from` too, the id of the link the app is a copy of. */
 const GITHUB_REPO = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/(?!\.\.?$)[A-Za-z0-9._-]{1,100}$/;
 export function readShare(body) {
   if (!body || typeof body !== "object" || Array.isArray(body)) return null;
-  const known = ["name", "by", "line", "words", "ideas", "asks", "shape", "releases", "picture", "icon", "github"];
+  const known = ["name", "by", "line", "words", "ideas", "asks", "shape", "releases", "picture", "icon", "github", "from"];
   if (Object.keys(body).some((key) => !known.includes(key))) return null;
   const name = tidy(body.name, LIMITS.name);
   const words = tidy(body.words, LIMITS.words, { lines: true });
@@ -159,9 +159,10 @@ export function readShare(body) {
   const icon = picture(body.icon, LIMITS.icon, { square: true });
   // The app's public repository on GitHub, as "owner/name", which the page links to: nothing else is taken.
   const github = body.github == null || body.github === "" ? null : GITHUB_REPO.test(body.github) ? body.github : undefined;
-  if (!name || !words || line == null || by == null || ideas.includes(null) || asks.includes(null) || shape === undefined || releases?.includes(null) || !shot || !icon || github === undefined) return null;
+  const from = body.from == null ? undefined : isID(body.from) ? body.from : null;
+  if (!name || !words || line == null || by == null || ideas.includes(null) || asks.includes(null) || shape === undefined || releases?.includes(null) || !shot || !icon || github === undefined || from === null) return null;
   return { name, by, line, words, ideas, asks, shape, releases: releases?.sort((a, b) => b.date.localeCompare(a.date)),
-    picture: shot.bytes ? shot : null, icon: icon.bytes ? icon : null, github };
+    picture: shot.bytes ? shot : null, icon: icon.bytes ? icon : null, github, from };
 }
 
 /** What anyone may see of a shared wish: never its secret. */
@@ -772,8 +773,11 @@ export function createShareHandler({ env = process.env, fetcher = fetch, store,
       const picture = share.picture && { url: await put("picture", share.picture), width: share.picture.width, height: share.picture.height };
       const icon = share.icon && { url: await put("icon", share.icon) };
       const time = now().toISOString();
+      // The link the app is a copy of, kept only while there's such a link and it isn't this one: a share that doesn't
+      // say, or names one that's gone, keeps what the record had.
+      const from = share.from && share.from !== wishID && (await kept.get(share.from)) ? share.from : null;
       const words = { name: share.name, by: share.by, line: share.line, words: share.words, ideas: share.ideas, asks: share.asks, shape: share.shape, github: share.github,
-        ...(share.releases ? { releases: share.releases } : {}), picture: picture || null, icon: icon || null };
+        ...(share.releases ? { releases: share.releases } : {}), ...(from ? { from } : {}), picture: picture || null, icon: icon || null };
       // Its name under the account stays what it was first given, whatever the app is called later.
       const named = earlier?.owner ? { owner: earlier.owner, app: earlier.app }
         : owner ? { owner, app: await claimAppName(kept, owner, words.name, wishID) } : {};
@@ -1287,10 +1291,21 @@ export function createIdeaMailHandler({ env = process.env, fetcher = fetch, stor
 }
 
 /** A shared wish for the page and its card, or null when there's none by that id (or it can't be read now). */
-export async function findWish(id, { env = process.env, fetcher = fetch, store } = {}) {
+export async function findWish(id, { env = process.env, fetcher = fetch, store, origin = null } = {}) {
   if (!isID(id)) return null;
-  try { return shown(await (store ?? cloudStore(env, fetcher)).get(id)); }
+  let kept, record;
+  try { kept = store ?? cloudStore(env, fetcher); record = await kept.get(id); }
   catch { return undefined; }
+  const wish = shown(record);
+  // Asked with the site's origin (the page): the link it came from, as that link is known now, `from` on its page. One
+  // taken down since, or that can't be read just now, is left out.
+  if (wish && origin && isID(record.from) && record.from !== id) {
+    try {
+      const source = await kept.get(record.from);
+      if (source) wish.from = { url: linkOf(origin, source), label: source.owner && source.app ? `${source.owner}/${source.app}` : source.name };
+    } catch {}
+  }
+  return wish;
 }
 
 /** Takes a shared wish down without its secret: for the Lamp team, when a link shows what it mustn't. */