@lampdotdev/lamp 0.0.0-stage → 0.36.2-nightly.16

package/cli/lamps/web-starter/style.css

@@ -0,0 +1,25 @@
+:root { --u: max(0.8vmin, 4px); }
+html, body {
+  margin: 0;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  background: #101418;
+  color: #f2f4f6;
+  font-family: -apple-system, "Samsung One", "LG Smart UI", "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  font-size: calc(var(--u) * 3.6);
+}
+#app {
+  box-sizing: border-box;
+  height: 100%;
+  padding: calc(var(--u) * 5);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  text-align: center;
+}
+h1 { font-size: calc(var(--u) * 8); margin: 0 0 calc(var(--u) * 2); }
+.status { opacity: 0.7; }
+/* What has the remote's focus is always plain to see from the sofa. */
+:focus { outline: calc(var(--u) * 0.6) solid #4da3ff; outline-offset: calc(var(--u) * 0.6); }

package/cli/link.mjs

@@ -0,0 +1,202 @@
+// lamp.dev's API for a shared link (site/lib/shared-wishes.js, which the limits here are read from), for lamp's own
+// `share` and for Lamp's app's Share Link card alike: a link made or changed, what it has now, its file or its playable
+// page sent in parts, the ideas people send, and taking it down. Only the link's secret changes it; the secret is
+// whoever shared it's alone, and is kept by whoever asks, never here.
+
+import { FILE_LIMITS, LIMITS } from "../site/lib/shared-wishes.js";
+import { Problem } from "./state.mjs";
+
+/** The site links are made on: lamp.dev, or another given for trying this against a copy of the site. */
+export const siteOrigin = () => (process.env.LAMP_SITE || "https://lamp.dev").replace(/\/+$/, "");
+
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+const megabytes = (bytes) => `${(bytes / 1_000_000).toFixed(bytes < 10_000_000 ? 1 : 0)} MB`;
+
+// What the site says when it turns something down, in plain words.
+const REFUSALS = {
+  invalid_wish: `the site didn't take the link's words or picture (a name of at most ${LIMITS.name} characters, words of at most ${LIMITS.words}, a line of at most ${LIMITS.line})`,
+  invalid_page: "the site didn't take the page: it needs index.html at its top",
+  invalid_part: "the site didn't take a part of the page",
+  parts_missing: "a part of the page didn't reach the site: share again",
+  file_too_large: `the page is more than the ${megabytes(FILE_LIMITS.total)} a link carries, packed`,
+  rate_limited: "the site has taken as many as it takes for now: try again in a while",
+  service_unavailable: "the site can't keep it just now: try again in a moment",
+  not_found: "the link is no longer there",
+  invalid_username: "a username is 2 to 30 lowercase letters, digits and dashes, starting and ending with a letter or digit, and not one of the site's own words",
+  username_taken: "that username is someone else's: choose another",
+  invalid_email: "that isn't an email address the site can write to",
+};
+
+/** The site couldn't be reached at all: offline, or the site is down. */
+export class Unreachable extends Problem {}
+
+/**
+ * One request to the site. A request that's the same however often it arrives is tried again, `tries` times in all,
+ * a little later each time, when the site can't be reached or can't answer just now; any other is sent once. A refusal
+ * carries the status the site gave it. No redirect is followed: a link's secret goes to the site and nowhere else.
+ */
+export async function call(method, url, { secret, account, json, bytes, tries = 1, seconds = 120 } = {}) {
+  const headers = {
+    ...(secret ? { authorization: `Bearer ${secret}` } : {}),
+    ...(account ? { "x-lamp-account": account } : {}),
+    ...(json ? { "content-type": "application/json" } : bytes ? { "content-type": "application/octet-stream" } : {}),
+  };
+  for (let attempt = 0; ; attempt++) {
+    let answer = null;
+    try { answer = await fetch(url, { method, headers, body: json ? JSON.stringify(json) : bytes, redirect: "manual", signal: AbortSignal.timeout(seconds * 1000) }); } catch {}
+    if (answer && answer.status < 500) {
+      const said = await answer.json().catch(() => null);
+      if (answer.ok) return { status: answer.status, said: said ?? {} };
+      const problem = new Problem(REFUSALS[said?.error] ?? `the site answered ${answer.status}`);
+      problem.status = answer.status;
+      throw problem;
+    }
+    if (attempt >= tries - 1) {
+      if (answer) { const problem = new Problem(REFUSALS.service_unavailable); problem.status = answer.status; throw problem; }
+      throw new Unreachable(`couldn't reach ${new URL(url).host}`);
+    }
+    await sleep(600 * 2 ** attempt);
+  }
+}
+
+/** An address the site gave, only when it's on the site itself. */
+function onSite(site, address) {
+  try { const url = new URL(address), home = new URL(site); return url.protocol === home.protocol && url.host === home.host ? url.href : null; } catch { return null; }
+}
+
+/**
+ * Makes the link, or changes what it shows (`earlier`: its id and secret), with `body` as the site takes it (its
+ * name, line, words, who it's by, the questions its page asks, its shape, picture and icon). A link the site no longer
+ * has is made again. Answers its id, its address and its secret.
+ */
+export async function publishLink({ site = siteOrigin(), body, earlier, account }) {
+  if (earlier) {
+    try {
+      const { said } = await call("PUT", `${site}/api/wishes?id=${encodeURIComponent(earlier.id)}`, { secret: earlier.secret, account, json: body });
+      // A change keeps the link; its address follows the name, so a rename shows in it (the old one still works).
+      return { id: earlier.id, url: onSite(site, said.url) ?? earlier.url ?? null, secret: earlier.secret };
+    } catch (error) { if (error.status !== 404) throw error; }
+  }
+  const { said } = await call("POST", `${site}/api/wishes`, { account, json: body });
+  const url = onSite(site, said.url);
+  if (typeof said.id !== "string" || typeof said.secret !== "string" || !url) throw new Problem("the site's answer couldn't be read");
+  return { id: said.id, url, secret: said.secret };
+}
+
+/**
+ * Asks for a maker's account (`username` and `email`), or with an address that has one, to sign in to it: answers
+ * `{ username, key, existing, sent }`. The key is the account's once the email's link is opened.
+ */
+export async function askAccount({ site = siteOrigin(), username, email }) {
+  const { said } = await call("POST", `${site}/api/accounts`, { json: { ...(username ? { username } : {}), email } });
+  if (typeof said.key !== "string" || typeof said.username !== "string") throw new Problem("the site's answer couldn't be read");
+  return said;
+}
+
+/** The username a key is an account's, once the email's link was opened; null before. */
+export async function accountName({ site = siteOrigin(), key }) {
+  const { said } = await call("GET", `${site}/api/accounts`, { secret: key, seconds: 20 });
+  return typeof said.username === "string" ? said.username : null;
+}
+
+/**
+ * What a followed link has now: its name, who it's by (null for nobody), its file's version (0 with no file), and the
+ * file's address, only from where the site keeps them. Null when it can't be asked, or is gone. Asks with nothing of
+ * the person's.
+ */
+export async function latestOf({ site = siteOrigin(), id, user, app }) {
+  let said;
+  const asked = id ? `id=${encodeURIComponent(id)}` : `user=${encodeURIComponent(user)}&app=${encodeURIComponent(app)}`;
+  try { ({ said } = await call("GET", `${site}/api/wishes?${asked}`)); } catch { return null; }
+  if (said.format !== 1 || !Number.isInteger(said.version)) return null;
+  let file = null;
+  try { const url = new URL(said.file); if (url.protocol === "https:" || (url.protocol === "data:" && new URL(site).protocol === "http:")) file = url.href; } catch {}
+  const by = typeof said.by === "string" ? said.by.trim().slice(0, LIMITS.by) : "";
+  return { id: typeof said.id === "string" ? said.id : id ?? null, name: typeof said.name === "string" ? said.name : null, by: by || null, version: said.version, file,
+    // Absent from a site from before that doesn't say; null while a link's first page is still being stored.
+    page: !("page" in said) ? undefined : Number.isInteger(said.page) ? said.page : null };
+}
+
+/**
+ * The site stores a page's files after it answers its last part, and the link shows the page before until they're in:
+ * waits until it shows `version` (a minute at most; a site from before that doesn't say is taken at its word).
+ */
+export async function pageUp({ site = siteOrigin(), id, version, said = () => {} }) {
+  for (let waited = 0; waited < 60; waited += 2) {
+    const now = await latestOf({ site, id });
+    if (!now || now.page === undefined || (Number.isInteger(now.page) && now.page >= version)) return;
+    if (waited === 0) said("Waiting for lamp.dev to put the page up…");
+    await sleep(2000);
+  }
+}
+
+const fileAddress = (site, id, more = "") => `${site}/api/wish-file?id=${encodeURIComponent(id)}${more}`;
+
+/**
+ * Sends the link's file in parts, and has the site put them together in place of any it had: the wish's file, or with
+ * `page` its playable page, which the site unpacks and serves on the link's page. A part is the same whenever it's
+ * sent, so one whose connection dropped goes again. Answers the version the site gave it.
+ */
+export async function sendFile({ site = siteOrigin(), link, bytes, page = false, said = () => {} }) {
+  if (bytes.length > FILE_LIMITS.total) throw Object.assign(new Problem(`it's more than the ${megabytes(FILE_LIMITS.total)} a link carries`), { status: 413 });
+  const what = page ? "&what=page" : "", count = Math.max(1, Math.ceil(bytes.length / FILE_LIMITS.part));
+  for (let n = 0; n < count; n++) {
+    said(`Sending ${page ? "the page" : "the file"}: part ${n + 1} of ${count}`);
+    await call("PUT", fileAddress(site, link.id, `${what}&part=${n}&of=${count}`), { secret: link.secret, bytes: bytes.subarray(n * FILE_LIMITS.part, (n + 1) * FILE_LIMITS.part), tries: 4 });
+  }
+  // Putting a page together stores each of its files, which for a big game's takes minutes (the site gives it five).
+  return (await call("POST", fileAddress(site, link.id, what), { secret: link.secret, seconds: 330 })).said.version ?? null;
+}
+
+/** Takes the link's file away, which keeps showing the idea, and its page with it; with `page` only the page. */
+export async function removeFile({ site = siteOrigin(), link, page = false }) {
+  try { await call("DELETE", fileAddress(site, link.id, page ? "&what=page" : ""), { secret: link.secret, tries: 3 }); }
+  catch (error) { if (error.status !== 404) throw error; }
+}
+
+/** The ideas sent to the link that are still open, oldest first: each with its number. Only the link's secret reads them. */
+export async function ideasOf({ site = siteOrigin(), link, earlier = false }) {
+  try { return (await call("GET", `${site}/api/wish-ideas?id=${encodeURIComponent(link.id)}${earlier ? "&earlier=1" : ""}`, { secret: link.secret })).said.ideas ?? []; }
+  catch (error) { if (error.status === 404) return []; throw error; }
+}
+
+/** Lets an idea go: with `built` it's in, and the site first writes to whoever asked to hear. Whether it did. */
+export async function removeIdea({ site = siteOrigin(), link, n, built = false, note }) {
+  try {
+    const { said } = await call("DELETE", `${site}/api/wish-ideas?id=${encodeURIComponent(link.id)}&n=${Number(n)}${built ? "&built=1" : ""}`,
+      { secret: link.secret, ...(note ? { json: { note } } : {}) });
+    return { notified: said.notified === true };
+  } catch (error) { if (error.status === 404) return { notified: false }; throw error; }
+}
+
+/**
+ * Says something more about an idea, its sender emailed if they gave an address, and answers whether they were;
+ * without a note, only that the maker has seen to their answer.
+ */
+export async function replyIdea({ site = siteOrigin(), link, n, note }) {
+  try {
+    const { said } = await call("PATCH", `${site}/api/wish-ideas?id=${encodeURIComponent(link.id)}&n=${Number(n)}`,
+      { secret: link.secret, ...(note ? { json: { note } } : {}) });
+    return { notified: said.notified === true };
+  } catch (error) {
+    if (error.status === 404) throw new Problem(`there's no idea ${Number(n)} on this link`);
+    if (error.status === 429) throw new Problem(`idea ${Number(n)} has as many messages as it can keep`);
+    throw error;
+  }
+}
+
+/**
+ * The maker's own address for the link's ideas and replies, as `{ email, confirmed }`; with `email`, given ("" takes it
+ * away), and the site emails it to confirm first.
+ */
+export async function makerOf({ site = siteOrigin(), link, email }) {
+  const { said } = await call(email === undefined ? "GET" : "PUT", `${site}/api/wish-ideas?id=${encodeURIComponent(link.id)}&maker=1`,
+    { secret: link.secret, ...(email === undefined ? {} : { json: { email } }) });
+  return { email: typeof said.email === "string" ? said.email : null, confirmed: said.confirmed === true, ...(email ? { sent: said.sent === true } : {}) };
+}
+
+/** Takes the link down, with its page and the ideas sent to it. A link the site no longer has is down already. */
+export async function removeLink({ site = siteOrigin(), link }) {
+  try { await call("DELETE", `${site}/api/wishes?id=${encodeURIComponent(link.id)}`, { secret: link.secret }); }
+  catch (error) { if (error.status !== 404) throw error; }
+}

package/cli/local-ai.mjs

@@ -0,0 +1,193 @@
+// `lamp ai`: the AI for a page shared on lamp.dev, answered on this computer with the person's own Claude Code or
+// Codex (ai.mjs), the way `lamp dev` answers a page it serves. A shared page is away from Lamp, so lamp.js asks here,
+// at a port of this computer's own (127.0.0.1), where a browser lets an https page call plain http.
+//
+// Only the person decides which pages spend their subscription. Each shared link plays from an origin of its own
+// (`playOrigin` in site/lib/shared-wishes.js: <the link's id in hex>.play.lamp.dev), which a browser always names in
+// the request and a page can't change, so an approval is for one link's page: the first time it asks, the person is
+// asked in the terminal, and the page is given a token it keeps and sends from then on. Nothing else is answered:
+// another site, another link's page, or a request naming this computer by another name (a site that rebinds its own
+// name to 127.0.0.1) is refused. Whether there's an AI here (`/ai/status` and the probes) is answered without one, so a
+// page can say what it can do before anyone is asked.
+
+import { createServer } from "node:http";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { answer as answerAI, engine } from "./ai.mjs";
+
+/** The port lamp.js on a shared page asks (`LOCAL_AI` there): one, fixed, since the page can't be told another. */
+export const LOCAL_AI_PORT = 47423;
+const PLAY_HOST = "play.lamp.dev";
+const MOST = 2_000_000, AT_ONCE = 3, ASKING_FOR = 120_000;
+const ROUTES = new Set(["/ai/status", "/ai", "/ai/act", "/ai/decide", "/ai/hear", "/ai/image"]);
+
+const keptFile = () => join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "shared-pages-ai.json");
+
+/** The pages the person has let use their AI, by origin: `{ token, id, name, at }`. */
+export function allowed() {
+  try { const kept = JSON.parse(readFileSync(keptFile(), "utf8")); return kept && typeof kept === "object" ? kept : {}; } catch { return {}; }
+}
+function keep(all) {
+  const file = keptFile();
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file + ".new", JSON.stringify(all, null, 2), { mode: 0o600 });
+  renameSync(file + ".new", file);
+}
+/** Forgets every page let in: each asks again. */
+export function forgetAllowed() { if (existsSync(keptFile())) rmSync(keptFile()); }
+
+/** Forgets one page let in, by its origin: it asks again the next time it uses the AI. */
+export function forgetPage(origin) {
+  const all = allowed();
+  if (!(origin in all)) return;
+  delete all[origin];
+  if (Object.keys(all).length) keep(all); else forgetAllowed();
+}
+
+/** The link a shared page's origin plays, by its id, or null for any other origin. */
+export function linkOf(origin) {
+  let url;
+  try { url = new URL(origin); } catch { return null; }
+  if (url.protocol !== "https:" || url.port || !url.host.endsWith("." + PLAY_HOST)) return null;
+  const hex = url.host.slice(0, -PLAY_HOST.length - 1);
+  if (!/^(?:[0-9a-f]{2}){10}$/.test(hex)) return null;
+  const id = Buffer.from(hex, "hex").toString();
+  return /^[A-Za-z0-9]{10}$/.test(id) ? id : null;
+}
+
+const same = (a, b) => {
+  if (typeof a !== "string" || typeof b !== "string") return false;
+  const x = Buffer.from(a), y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+};
+
+/**
+ * Answers shared pages' AI until it's closed. `ask(question, page)` puts a yes-or-no to the person and resolves true
+ * for yes; by default it's the terminal's, and without a terminal nothing is let in. `answer(path, body, page)` is the
+ * AI's [status, reply]: the person's Claude Code, Codex or OpenRouter key by default, Lamp's own AI when Lamp's app runs this
+ * (`sharedPages` in calls.mjs). Resolves to the server once it listens.
+ */
+export async function serveLocalAI({ port = LOCAL_AI_PORT, ask = askInTerminal(), answer = answerAI, said = console.log } = {}) {
+  const busy = new Map(), queued = new Map(), refused = new Set(), waiting = new Map();
+  // A few of a page's requests run at once and the rest wait their turn, since lamp.js asks many at a time
+  // (`LampAI.decideEach`) and takes a refusal as that item's answer.
+  const turn = (origin) => {
+    if ((busy.get(origin) || 0) < AT_ONCE) { busy.set(origin, (busy.get(origin) || 0) + 1); return Promise.resolve(); }
+    return new Promise((go) => queued.set(origin, [...(queued.get(origin) || []), go]));
+  };
+  const done = (origin) => {
+    const next = queued.get(origin)?.shift();
+    if (next) next();
+    else busy.set(origin, busy.get(origin) - 1);
+  };
+  // One question at a time in the terminal; a page that asks again while it's waiting gets the same answer, and one
+  // the person said no to isn't asked about again while this runs.
+  let asking = Promise.resolve();
+  const askAbout = (origin, id, name) => {
+    if (waiting.has(origin)) return waiting.get(origin);
+    const asked = asking.then(async () => {
+      const kept = allowed()[origin];
+      if (kept) return kept.token;
+      const titled = name ? `"${name}" ` : "A page ";
+      const yes = await ask(`${titled}shared at lamp.dev/w/${id} wants to use your ${engineName()} here. Allow it?`, { id, name });
+      if (!yes) { refused.add(origin); return null; }
+      const token = randomBytes(32).toString("base64url");
+      keep({ ...allowed(), [origin]: { token, id, name: name || "", at: new Date().toISOString() } });
+      said(`Allowed ${name ? `"${name}"` : `lamp.dev/w/${id}`}. lamp ai --forget takes it back.`);
+      return token;
+    });
+    asking = asked.catch(() => {});
+    waiting.set(origin, asked);
+    asked.finally(() => waiting.delete(origin));
+    return asked;
+  };
+
+  const server = createServer(async (request, response) => {
+    const origin = request.headers.origin || "";
+    const id = linkOf(origin);
+    const reply = (status, body) => {
+      const headers = { "Content-Type": "application/json", "Cache-Control": "no-store", Vary: "Origin" };
+      if (id) headers["Access-Control-Allow-Origin"] = origin;
+      response.writeHead(status, headers);
+      response.end(JSON.stringify(body));
+    };
+    // Only this computer's own name for itself: a site that points a name of its own at 127.0.0.1 is someone else.
+    const host = String(request.headers.host || "").replace(/:\d+$/, "");
+    if (host !== "127.0.0.1" && host !== "localhost") return reply(403, { error: "Not here." });
+    if (!id) return reply(403, { error: "Only a page shared on lamp.dev can ask here." });
+    const url = new URL(request.url, "http://127.0.0.1");
+    if (request.method === "OPTIONS") {
+      response.writeHead(204, {
+        "Access-Control-Allow-Origin": origin,
+        "Access-Control-Allow-Methods": "POST",
+        "Access-Control-Allow-Headers": "Authorization, Content-Type",
+        "Access-Control-Allow-Private-Network": "true",
+        "Access-Control-Max-Age": "600",
+        Vary: "Origin",
+      });
+      return response.end();
+    }
+    if (request.method !== "POST") return reply(405, { error: "Method not allowed." });
+
+    let body = {};
+    try {
+      const chunks = [];
+      let size = 0;
+      for await (const chunk of request) {
+        size += chunk.length;
+        if (size > MOST) return reply(413, { error: "That's too much to ask at once." });
+        chunks.push(chunk);
+      }
+      const text = Buffer.concat(chunks).toString();
+      body = text ? JSON.parse(text) : {};
+    } catch { return reply(400, { error: "That wasn't JSON." }); }
+
+    if (url.pathname === "/pair") {
+      if (refused.has(origin)) return reply(403, { error: "Not allowed on this computer." });
+      const name = typeof body?.name === "string" ? body.name.replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 60) : "";
+      const token = await askAbout(origin, id, name);
+      return token ? reply(200, { token }) : reply(403, { error: "Not allowed on this computer." });
+    }
+    if (!ROUTES.has(url.pathname)) return reply(404, { error: "Not found." });
+    // What there is to answer with, asked before anyone is let in: only the routes whose probe asks no model.
+    const asksNothing = url.pathname === "/ai/status" || (body?.probe === true && (url.pathname === "/ai/act" || url.pathname === "/ai/hear"));
+    if (asksNothing) {
+      const [status, answered] = await answer(url.pathname, url.pathname === "/ai/status" ? {} : { probe: true }, { id });
+      return reply(status, answered);
+    }
+    const kept = allowed()[origin];
+    const given = String(request.headers.authorization || "").replace(/^Bearer\s+/i, "");
+    if (!kept || !same(given, kept.token)) return reply(401, { error: "This page isn't allowed to use the AI here yet." });
+    await turn(origin);
+    try {
+      const [status, answered] = await answer(url.pathname, body, { id });
+      reply(status, answered);
+    } catch (error) {
+      reply(502, { error: error?.message || "The AI didn't answer." });
+    } finally {
+      done(origin);
+    }
+  });
+  await new Promise((done, fail) => { server.once("error", fail); server.listen(port, "127.0.0.1", () => { server.off("error", fail); done(); }); });
+  return server;
+}
+
+const engineName = () => ({ codex: "Codex", openrouter: "OpenRouter key" })[engine()] ?? "Claude Code";
+
+/** A yes-or-no in the terminal, or always no without one. */
+export function askInTerminal({ input = process.stdin, output = process.stdout } = {}) {
+  return (question) => {
+    if (!input.isTTY) {
+      output.write(`${question} No: lamp ai can only ask in a terminal.\n`);
+      return Promise.resolve(false);
+    }
+    const lines = createInterface({ input, output });
+    return new Promise((done) => {
+      const timer = setTimeout(() => { output.write("\nNo answer, so not allowed.\n"); lines.close(); done(false); }, ASKING_FOR);
+      lines.question(`${question} [y/N] `, (said) => { clearTimeout(timer); lines.close(); done(/^y(es)?$/i.test(said.trim())); });
+    });
+  };
+}