@lampdotdev/lamp 0.36.2-nightly.16 → 0.36.2-nightly.19

package/README.md

@@ -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/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/mac-starter/.lamp/meta.json

@@ -1 +1 @@
-{"instance":"0B0B3EAA-A528-48AA-99D7-F9045656CF78","name":"Zqx App Name","exe":"ZqxAppName","platform":"mac"}
+{"platform":"mac","instance":"12A4CA51-92CD-4391-8AD0-548165ABFCAE","exe":"ZqxAppName","name":"Zqx App Name"}

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.16",
+  "version": "0.36.2-nightly.19",
   "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. */