@lampdotdev/lamp 0.35.0 → 0.36.2-nightly.16

package/cli/skill/SKILL.md

@@ -34,8 +34,9 @@ looked earlier, `--reopen` puts it right.
 `{{lamp}} new path/to/folder --web --name "Its Name"` makes a new web app's page from Lamp's starting files:
 `index.html`, `style.css` and `app.js`, which are yours to write, `APP.md`, and `lamp.js`, Lamp's building blocks for
 a page (saved data with `LampStore`, the app's files and more). Read Lamp's `web-app` skill before writing it, and
-the comments in `lamp.js` for how each block is used; never edit `lamp.js`. What a block asks of Lamp's app as the
-page runs (its AI) isn't answered here. A page that wants none of Lamp's needs no starting files: write its
+the comments in `lamp.js` for how each block is used; never edit `lamp.js`. Its AI (`LampAI`: ask, act, decide) is
+answered by lamp itself on this Mac, with the person's own Claude Code or Codex (or OpenRouter, with their key in `OPENROUTER_API_KEY`), in every page lamp runs here (`dev`,
+`open`, `look`, `use`); pictures and hearing need Lamp's app. Shared on lamp.dev, it's answered on the computer the page is played on while Lamp is open there or `{{lamp}} ai` runs there in a terminal, once the person allows that page. Never put a key or a model provider's address in the page. A page that wants none of Lamp's needs no starting files: write its
 `index.html` in an empty folder.
 
 ## A Mac app
@@ -98,12 +99,16 @@ here: keep its license file, its copyright headers and its author's credit on sc
 
 1. **Show the person the app** once, when you start, unless they don't want to watch: `{{lamp}} open`. It opens a
    window they can use and play in while you work, and returns at once.
-2. **Change the files.**
+2. **Change the files.** First say what you're changing, in a few words of theirs: `{{lamp}} changing "Rain on the
+   roads"`. Do it before every change, however small: the app shows it on the card it puts up as the change goes in,
+   and without it the card says only that it's updating. It stands until you say something new.
 3. **Look**: `{{lamp}} look`. It waits for the change to go in, then answers how it went, a picture of the page (a
    file: read it; the last forty are kept), the screen as text, and the errors and the log since your last look. Look
    after every change, and read the errors and the picture before saying it works. `{{lamp}} look --reopen` opens the
    page again from its beginning first, a game with its saves kept: what someone opening it sees. `--size 900x600`
    looks at it as a window of that size shows it, for a layout that has to hold at any shape (with no window open).
+   When the answer says lamp found no Chrome, Edge, Brave or Chromium, there's no picture and `use` can't play the
+   page: tell the person, since only they can install one.
 
 Nothing has to be running first. With no window open, `look` runs the app itself in a copy of the page nobody sees,
 opened from the files as they are, so the first look has no changes to report. The copy goes on running between
@@ -175,14 +180,34 @@ every command here works on a web app, a game, a screen or a Mac app in one, and
 
 Only when the person asks: a link is public, and anyone who has it can play the page.
 
-- `{{lamp}} share --words "What it is, in a sentence or a few"` puts the page on lamp.dev and answers its link. `--line`
-  is a line under its name, `--asks "Found a bug?|What's missing?"` what the box under the page asks people, and
-  `--by "Their Name"` who it's by: only a name the person gave you to show. A page that's logging errors isn't shared
-  until they're put right.
-- Again, after changes, it sends the page as it is now to the same link, with the same words unless you give new ones.
-- `{{lamp}} ideas` lists what people playing it have sent. Once one is in the game and the game shared again,
+- Start with `{{lamp}} share --preview`: it says what would go and sends nothing. Show the person, and share only once they
+  say so.
+- **A web app or game of Lamp's own** (its folder is in Lamp's) is shared here like any other page, whether Lamp is open
+  or not, to the link Lamp already has for it, and `ideas` and `unshare` work on that link too. Run `{{lamp}} share` with
+  no words of your own (it keeps the link's), and give `--line`, `--by` or `--asks "a|b"` only for what the person
+  wants changed.
+- **Any other app of Lamp's** (a Mac or iPhone app, a wish of several; the preview says it's going through Lamp) is
+  shared by Lamp, which must be open, filled as its Share Link card fills itself: its words, the questions and what's new
+  Lamp writes, its file, its GitHub release. Give `--notes "What's new|And more"` and the rest only for what the person
+  wants changed. Its ideas and taking it down are on Lamp's Share Link card.
+- **Any other page:** `{{lamp}} share --words "What it is, in a sentence or a few"` puts it on lamp.dev and answers its
+  link. `--line` is a line under its name, `--asks "Found a bug?|What's missing?"` what the box under the page asks
+  people, and `--by "Their Name"` who it's by, when they want another name than the one it goes out with (the name they last
+  gave, or Lamp's, or their name on this computer, which the share says). A link goes under the person's username on
+  lamp.dev (`lamp.dev/<username>/<app>`) once they have one: the first time you share, ask them which username they want
+  and their email, and run `{{lamp}} account <username> --email <theirs>`; they confirm it from the email, and the link
+  moves there at its next share. `{{lamp}} account` says which they're signed in as. A page that's logging errors
+  isn't shared until they're put right. Again, after changes, it sends the page as it is now to the same link, with the
+  same words unless you give new ones.
+- `{{lamp}} ideas` lists what people playing it have sent, each with the address of a picture of the app as they saw
+  it when they kept one in: look at it before building the idea. Once one is in the game and the game shared again,
   `{{lamp}} ideas in <number>` says so, and whoever asked to hear is written to; `{{lamp}} ideas dismiss <number>` lets
-  one go.
+  one go. Words after the number are a note to whoever sent it, shown on the link's page and put in that email: write
+  one only when the person asks you to answer them, in their words. Senders can answer by email: `{{lamp}} ideas` shows
+  what's been said under each idea, and those they've answered; `{{lamp}} ideas reply <number> <words>` answers again,
+  and `{{lamp}} ideas done <number>` leaves one without a word. `{{lamp}} ideas --earlier` lists those seen to. `{{lamp}} ideas email <address>` sends new ideas and replies to the
+  person's own address too, once they confirm it from the email it sends (`off` stops them): only with an address
+  they gave you.
 - `{{lamp}} unshare` takes the link down.
 
 Tell the person the link, and that it's public.

package/cli/state.mjs

@@ -22,6 +22,9 @@ export class Problem extends Error {}
 
 /** The runtime whose presence makes a page a game's (`GamePage.runtimeFile`). */
 export const RUNTIME_FILE = "lamp-game.js";
+// The app's notes, at the top of its page: what it is and how it's made, for whoever works on it. Never part of the
+// page: saving it changes nothing a page runs, and a shared page goes without it.
+export const NOTES_FILE = "APP.md";
 
 /**
  * How the folder is laid out: an app Lamp made keeps its page in Web/, and any other folder with an index.html is a

package/cli/update.mjs

@@ -1,32 +1,81 @@
-// Whether a newer lamp is out, for a lamp installed from npm (@lampdotdev/lamp). The copy in Lamp's app updates with
-// Lamp (Sparkle) and a checkout with its repository, so neither asks. At most once a day a process of its own asks npm's
-// registry, without holding up the command, and keeps what it heard; the next command says so in one line, once a day,
-// with the command that updates it. lamp never updates itself: a global install is the person's.
+// Whether a newer lamp is out. For a lamp installed from npm (@lampdotdev/lamp): at most once a day a process of its own
+// asks npm's registry, without holding up the command, and keeps what it heard; the next command says so in one line,
+// once a day, with the command that updates it. lamp never updates a global install: it's the person's.
+// For the copy in Lamp's app, run as the person's `lamp` (lamp.sh): lamp is published on npm at every change to main
+// (`nightly`) as well as with each release (`latest`), much sooner than Lamp's app can be built, so at most once an hour
+// the same background process fetches the newest of its channel into ~/.lamp/cli when it's newer than the app's own,
+// and the launcher runs that one from then on, until the app has caught up. Lamp's own calls of lamp (LampCLI.swift)
+// never do: the app and the lamp inside it are always the same.
 
-import { spawn } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const NAME = "@lampdotdev/lamp";
-const DAY = 24 * 60 * 60 * 1000;
+const DAY = 24 * 60 * 60 * 1000, HOUR = 60 * 60 * 1000;
 const here = dirname(fileURLToPath(import.meta.url));
 const cache = () => join(process.env.LAMP_DEV_HOME ? dirname(process.env.LAMP_DEV_HOME) : join(homedir(), ".lamp"), "update.json");
 
 /** Whether this copy is one npm installed, and so one npm updates. */
 const fromNpm = () => here.includes(`${sep}node_modules${sep}@lampdotdev${sep}lamp${sep}`);
 
-const own = () => { try { return JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8")).version ?? null; } catch { return null; } };
+// npm's package has its package.json at its top, beside cli/; Lamp's app carries lamp's own in cli/ (build.sh).
+const own = () => {
+  for (const file of [join(here, "..", "package.json"), join(here, "package.json")]) {
+    try { const { name, version } = JSON.parse(readFileSync(file, "utf8")); if ((name === NAME || name === "lamp") && version) return version; } catch {}
+  }
+  return null;
+};
+
+/**
+ * The npm channel a copy run as the person's `lamp` from Lamp's app follows: Lamp Nightly's, `nightly`; Lamp's, `latest`.
+ * None for Lamp Dev (a build from source has its checkout's lamp) or any other copy.
+ */
+const channel = () => {
+  if (!process.env.LAMP_FROM_APP || !process.env.LAMP_LAUNCHER) return null;
+  const app = process.env.LAMP_APP ?? "";
+  return app === "dev.lamp.host.nightly" ? "nightly" : app === "dev.lamp.host" ? "latest" : null;
+};
+/** Where fetched copies are kept, and the launcher's note of which to run (lamp.sh reads it). */
+const fetched = () => join(dirname(cache()), "cli");
 const read = () => { try { return JSON.parse(readFileSync(cache(), "utf8")); } catch { return {}; } };
 const keep = (state) => { try { mkdirSync(dirname(cache()), { recursive: true }); writeFileSync(cache(), JSON.stringify(state)); } catch {} };
 
-/** Whether version a is newer than b, by their numbers (a pre-release is older than its release). */
+/** This lamp's version, and where it came from, for `lamp --version`. */
+export function versionLine() {
+  const mine = own() ?? "unknown";
+  const app = process.env.LAMP_BUNDLED_VERSION;
+  if (process.env.LAMP_FROM_APP && app && app !== mine) return `lamp ${mine} (fetched from npm, newer than the ${app} in Lamp's app)`;
+  if (process.env.LAMP_FROM_APP) return `lamp ${mine} (in Lamp's app)`;
+  return `lamp ${mine}${fromNpm() ? "" : " (from a checkout)"}`;
+}
+
+/**
+ * Whether version a is newer than b, as semver orders them: by their numbers, a pre-release older than its release, and
+ * two pre-releases by their parts in turn, numbers as numbers (0.36.2-nightly.10 after 0.36.2-nightly.9). Build
+ * metadata (+…) says nothing about order.
+ */
 export function newer(a, b) {
-  const parts = (version) => { const [main, pre] = String(version).split("-"); return { numbers: main.split(".").map(Number), pre: pre ?? null }; };
+  const parts = (version) => {
+    const [main, ...rest] = String(version).split("+")[0].split("-");
+    return { numbers: main.split(".").map(Number), pre: rest.length ? rest.join("-").split(".") : null };
+  };
   const x = parts(a), y = parts(b);
   for (let i = 0; i < 3; i++) if ((x.numbers[i] || 0) !== (y.numbers[i] || 0)) return (x.numbers[i] || 0) > (y.numbers[i] || 0);
-  return y.pre !== null && x.pre === null;
+  if (!x.pre || !y.pre) return !x.pre && !!y.pre;
+  for (let i = 0; i < Math.max(x.pre.length, y.pre.length); i++) {
+    const p = x.pre[i], q = y.pre[i];
+    if (p === undefined || q === undefined) return q === undefined;
+    if (p === q) continue;
+    const pn = /^\d+$/.test(p), qn = /^\d+$/.test(q);
+    if (pn && qn) return Number(p) > Number(q);
+    if (pn !== qn) return qn;   // a word part outranks a number part
+    return p > q;
+  }
+  return false;
 }
 
 /**
@@ -35,7 +84,15 @@ export function newer(a, b) {
  * LAMP_NO_UPDATE_CHECK set.
  */
 export function updateNotice() {
-  if (!fromNpm() || process.env.CI || process.env.LAMP_NO_UPDATE_CHECK) return null;
+  if (process.env.CI || process.env.LAMP_NO_UPDATE_CHECK) return null;
+  if (channel()) {
+    const state = read(), now = Date.now();
+    if (!(state.fetchChecked > now - HOUR)) {
+      try { spawn(process.execPath, [fileURLToPath(import.meta.url), "--fetch", channel()], { detached: true, stdio: "ignore" }).unref(); } catch {}
+    }
+    return null;
+  }
+  if (!fromNpm()) return null;
   const mine = own(), state = read(), now = Date.now();
   if (!(state.checked > now - DAY)) {
     try { spawn(process.execPath, [fileURLToPath(import.meta.url), "--check"], { detached: true, stdio: "ignore" }).unref(); } catch {}
@@ -55,3 +112,51 @@ if (process.argv[1] === fileURLToPath(import.meta.url) && process.argv[2] === "-
     if (typeof latest === "string" && /^\d+\.\d+\.\d+/.test(latest)) keep({ ...read(), checked: Date.now(), latest });
   } catch {}
 }
+
+// The background fetch, for the copy in Lamp's app: the newest lamp of its channel, when it's newer than the app's own,
+// checked against npm's integrity hash, unpacked into ~/.lamp/cli/<version>, and named for the launcher with the app's
+// version it's newer than, so an app updated since runs its own again.
+if (process.argv[1] === fileURLToPath(import.meta.url) && process.argv[2] === "--fetch") {
+  const tag = process.argv[3];
+  keep({ ...read(), fetchChecked: Date.now() });
+  const app = process.env.LAMP_BUNDLED_VERSION || own();
+  try {
+    const answer = await fetch(`https://registry.npmjs.org/${NAME.replace("/", "%2F")}/${encodeURIComponent(tag)}`, { signal: AbortSignal.timeout(8000) });
+    const { version, dist } = answer.ok ? await answer.json() : {};
+    const folder = join(fetched(), String(version));
+    if (typeof version === "string" && /^\d+\.\d+\.\d+(-[0-9A-Za-z.]+)?$/.test(version) && app && newer(version, app)
+        && typeof dist?.tarball === "string" && /^sha512-/.test(dist?.integrity ?? "")) {
+      if (!existsSync(join(folder, "package", "cli", "lamp.mjs"))) {
+        const bytes = Buffer.from(await (await fetch(dist.tarball, { signal: AbortSignal.timeout(60000) })).arrayBuffer());
+        if (`sha512-${createHash("sha512").update(bytes).digest("base64")}` !== dist.integrity) throw new Error("integrity");
+        const part = `${folder}.part`;
+        rmSync(part, { recursive: true, force: true });
+        mkdirSync(part, { recursive: true });
+        writeFileSync(join(part, "lamp.tgz"), bytes);
+        if (spawnSync("tar", ["xzf", "lamp.tgz"], { cwd: part }).status !== 0) throw new Error("unpack");
+        rmSync(join(part, "lamp.tgz"));
+        rmSync(folder, { recursive: true, force: true });
+        renameSync(part, folder);
+      }
+      // The one used until now is retired as of now: its week starts here, not from when it was fetched.
+      let before = null;
+      try { before = readFileSync(join(fetched(), "use"), "utf8").split("\n")[1] || null; } catch {}
+      if (before && dirname(before) !== folder) { try { const now = new Date(); utimesSync(dirname(before), now, now); } catch {} }
+      writeFileSync(join(fetched(), "use"), `${app}\n${join(folder, "package")}\n`);
+      // Older ones go once they've been out of use a week (the launcher touches the one it runs, and the one retired above
+      // was touched as it was): a `lamp dev` started from one may run for days, reading its files (libraries,
+      // controllers) as it goes.
+      // Never one a process running now was started from (a `lamp dev` that has run past its week): its command line
+      // names the copy's lamp.mjs.
+      const running = spawnSync("ps", ["-axo", "command"], { encoding: "utf8" }).stdout ?? "";
+      for (const other of readdirSync(fetched())) {
+        if (other === "use" || other === String(version) || other.endsWith(".part")) continue;
+        const at = join(fetched(), other);
+        if (running.includes(`${at}${sep}`)) continue;
+        try { if (statSync(at).mtimeMs < Date.now() - 7 * DAY) rmSync(at, { recursive: true, force: true }); } catch {}
+      }
+      // The one in use is touched, so it's counted from when it was last named.
+      try { const now = new Date(); utimesSync(folder, now, now); } catch {}
+    }
+  } catch {}
+}

package/package.json

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