letmeknow-cli 0.4.3 → 0.4.4

package/README.md

@@ -64,14 +64,6 @@ The preview URL is a bearer capability. The relay receives the served files and
 
 The CLI's Vite configuration is disabled and its filesystem access is limited to the selected folder. The CLI itself still requires an outbound network connection to the relay. It does not accept inbound browser connections.
 
-## Hosted compatibility
-
-Existing clients using the older command protocol can still connect explicitly without a folder:
-
-```bash
-LETMEKNOW_URL=https://letmeknow.dev npx letmeknow-cli
-```
-
 ## Development
 
 ```bash

package/SKILL.md

@@ -92,9 +92,3 @@ The CLI disables Vite config discovery and limits filesystem access to the selec
 ## Stop
 
 Send `SIGINT` or `SIGTERM` to stop the CLI. The relay session expires after producer disconnect. `--skill` prints these instructions without starting a session.
-
-Existing clients using the older hosted command protocol can still connect explicitly without a folder:
-
-```bash
-LETMEKNOW_URL=https://letmeknow.dev npx letmeknow-cli
-```

package/bin/letmeknow.js

@@ -1,6 +1,446 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeSync } from "node:fs";
+import { createServer } from "vite";
+import { existsSync, readFileSync, statSync, writeSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
+import { Readable, Writable } from "node:stream";
+
+const MAX_BODY_BYTES = 1024 * 1024;
+const GRACE_SECONDS = 10 * 60;
+const CONNECTION_TIMEOUT = 10_000;
+const MAX_RETRY_DELAY = 5_000;
+const credentialPattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const clientPath = "/__letmeknow_client.js";
+const clientId = "\0letmeknow-client";
+const client = String.raw`
+const key="letmeknow-client:"+location.host+location.pathname;
+const draftKey="letmeknow-draft:"+location.host+location.pathname;
+let credential=sessionStorage.getItem(key);
+let socket;
+let retryTimer;
+let terminal=false;
+const stateKey=(control,index)=>control.id?"#"+control.id:(control.form?.id??"")+":"+control.name+":"+control.type+":"+index;
+const controls=root=>[...root.querySelectorAll("input,select,textarea")];
+const snapshot=()=>{
+  const state=new Map();
+  let activeKey;
+  for(const [index,control] of controls(document).entries()){
+    const key=stateKey(control,index);
+    state.set(key,{value:control.value,checked:control.checked,selected:control instanceof HTMLSelectElement?[...control.options].filter(option=>option.selected).map(option=>option.value):undefined,start:typeof control.selectionStart==="number"?control.selectionStart:undefined,end:typeof control.selectionEnd==="number"?control.selectionEnd:undefined});
+    if(control===document.activeElement)activeKey=key;
+  }
+  return {state,activeKey,x:scrollX,y:scrollY};
+};
+const restore=saved=>{
+  let active;
+  for(const [index,control] of controls(document).entries()){
+    const state=saved.state.get(stateKey(control,index));
+    if(!state)continue;
+    if(control instanceof HTMLSelectElement&&state.selected)for(const option of control.options)option.selected=state.selected.includes(option.value);
+    else if(control.type==="checkbox"||control.type==="radio")control.checked=state.checked;
+    else{control.value=state.value;if(typeof state.start==="number"&&typeof control.setSelectionRange==="function")control.setSelectionRange(state.start,state.end)}
+    if(stateKey(control,index)===saved.activeKey)active=control;
+  }
+  active?.focus();
+  scrollTo(saved.x,saved.y);
+};
+const status=message=>{const element=document.querySelector("[data-letmeknow-status]");if(element)element.textContent=message};
+const sessionPrefix=location.pathname.match(/^\/s\/[a-f0-9]{20}\//)?.[0];
+const currentPath=()=>{const path=sessionPrefix?location.pathname.slice(sessionPrefix.length-1)||"/":location.pathname;return path.endsWith("/")?path+"index.html":path};
+const refresh=async()=>{
+  const saved=snapshot();
+  const response=await fetch(location.href,{cache:"no-store",headers:{Accept:"text/html"}});
+  if(!response.ok)throw new Error("page refresh failed");
+  const next=new DOMParser().parseFromString(await response.text(),"text/html");
+  document.title=next.title;
+  document.body.replaceChildren(...[...next.body.childNodes].filter(node=>!(node instanceof HTMLScriptElement&&node.hasAttribute("data-letmeknow-client"))));
+  const links=[...document.head.querySelectorAll("link[rel=stylesheet]")];
+  for(const link of links){const url=new URL(link.href);url.searchParams.set("_letmeknow",crypto.randomUUID());link.href=url}
+  restore(saved);
+};
+const update=path=>{if(path===currentPath()||path?.endsWith(".css"))refresh().catch(()=>status("The page could not be refreshed"))};
+const connect=()=>{
+  clearTimeout(retryTimer);retryTimer=undefined;
+  const url=new URL("_letmeknow/client",location.href);url.protocol=url.protocol==="https:"?"wss:":"ws:";
+  socket=credential?new WebSocket(url,credential):new WebSocket(url);
+  socket.onmessage=event=>{
+    const message=JSON.parse(event.data);
+    if(message.type==="credential"){credential=message.credential;sessionStorage.setItem(key,credential);return}
+    if(message.type==="challenge"){socket.send(JSON.stringify({type:"alive",nonce:message.nonce}));return}
+    if(message.type==="busy"){status("This session is open elsewhere");retryTimer=setTimeout(connect,message.retry_after*1000);return}
+    if(message.type==="file_update"){update(message.path);return}
+    if(message.type==="closed"){terminal=true;sessionStorage.removeItem(key);sessionStorage.removeItem(draftKey);status(message.message)}
+  };
+  socket.onclose=()=>{if(!terminal&&!retryTimer){status("Reconnecting…");retryTimer=setTimeout(connect,1000)}};
+  socket.onerror=()=>{};
+};
+document.addEventListener("submit",async event=>{
+  const form=event.target;
+  if(!(form instanceof HTMLFormElement))return;
+  event.preventDefault();
+  const submitter=event.submitter;
+  const method=(submitter?.getAttribute("formmethod")??form.getAttribute("method")??"get").toLowerCase();
+  if(method!=="get"&&method!=="post"){status("Only GET and POST forms are supported");return}
+  if(!form.checkValidity()){form.reportValidity();return}
+  let target;
+  try{target=new URL(submitter?.getAttribute("formaction")??form.getAttribute("action")??location.href,location.href)}catch{status("Invalid form action");return}
+  if(target.origin!==location.origin){status("Form actions must stay on this site");return}
+  if(sessionPrefix&&!target.pathname.startsWith(sessionPrefix))target.pathname=(sessionPrefix+target.pathname.replace(/^\//,""));
+  const values=new URLSearchParams();
+  for(const [name,value] of new FormData(form,submitter)){if(typeof value!=="string"){status("File inputs are not supported");return}values.append(name,value)}
+  const actionPath=sessionPrefix?target.pathname.slice(sessionPrefix.length-1)||"/":target.pathname;
+  const metadata={id:crypto.randomUUID(),form_id:form.id||null,action:actionPath+target.search,trigger:{id:submitter?.id||null,name:submitter?.getAttribute("name"),value:submitter?.getAttribute("value")}};
+  const headers={"X-LetMeKnow-Submission":"1","X-LetMeKnow-ID":encodeURIComponent(metadata.id),"X-LetMeKnow-Form-ID":encodeURIComponent(metadata.form_id??""),"X-LetMeKnow-Action":encodeURIComponent(metadata.action),"X-LetMeKnow-Trigger-ID":encodeURIComponent(metadata.trigger.id??""),"X-LetMeKnow-Trigger-Name":encodeURIComponent(metadata.trigger.name??""),"X-LetMeKnow-Trigger-Value":encodeURIComponent(metadata.trigger.value??"")};
+  if(method==="get")for(const [name,value] of values)target.searchParams.append(name,value);
+  try{const response=await fetch(target,{method:method.toUpperCase(),headers,...(method==="post"?{body:values}:{})});if(!response.ok)throw new Error();status("Submitted")}catch{status("The submission failed")}
+});
+connect();
+`;
+
+function encodedHeader(request, name) {
+  const value = request.headers[name];
+  if (typeof value !== "string" || value === "") return null;
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return null;
+  }
+}
+
+function addValue(values, name, value) {
+  if (Object.prototype.hasOwnProperty.call(values, name)) {
+    values[name] = Array.isArray(values[name]) ? [...values[name], value] : [values[name], value];
+  } else {
+    values[name] = value;
+  }
+}
+
+function readBody(request) {
+  return new Promise((resolveBody, reject) => {
+    const chunks = [];
+    let size = 0;
+    let tooLarge = false;
+    request.on("data", chunk => {
+      if (tooLarge) return;
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      size += buffer.byteLength;
+      if (size > MAX_BODY_BYTES) {
+        tooLarge = true;
+        request.resume();
+        reject(new Error("submission is too large"));
+        return;
+      }
+      chunks.push(buffer);
+    });
+    request.on("end", () => resolveBody(Buffer.concat(chunks)));
+    request.on("error", reject);
+  });
+}
+
+async function submission(request, response) {
+  const url = new URL(request.url || "/", "http://localhost");
+  const method = (request.method || "GET").toUpperCase();
+  const values = Object.create(null);
+  if (method === "GET") {
+    for (const [name, value] of url.searchParams) addValue(values, name, value);
+  } else if (method === "POST") {
+    const body = await readBody(request);
+    const contentType = request.headers["content-type"]?.split(";", 1)[0].trim();
+    if (contentType !== "application/x-www-form-urlencoded") throw new Error("unsupported submission encoding");
+    for (const [name, value] of new URLSearchParams(body.toString("utf8"))) addValue(values, name, value);
+  } else {
+    throw new Error("unsupported submission method");
+  }
+  const event = {
+    type: "submit",
+    id: encodedHeader(request, "x-letmeknow-id"),
+    method,
+    action: encodedHeader(request, "x-letmeknow-action") || url.pathname,
+    form_id: encodedHeader(request, "x-letmeknow-form-id"),
+    trigger: {
+      id: encodedHeader(request, "x-letmeknow-trigger-id"),
+      name: encodedHeader(request, "x-letmeknow-trigger-name"),
+      value: encodedHeader(request, "x-letmeknow-trigger-value")
+    },
+    values
+  };
+  process.stdout.write(`${JSON.stringify(event)}\n`);
+  response.statusCode = 204;
+  response.setHeader("Cache-Control", "no-store");
+  response.end();
+}
+
+class RelayRequest extends Readable {
+  constructor(packet) {
+    super();
+    this.method = packet.method;
+    this.url = packet.path;
+    this.originalUrl = packet.path;
+    this.headers = packet.headers || {};
+    this.httpVersion = "1.1";
+    this.httpVersionMajor = 1;
+    this.httpVersionMinor = 1;
+    this.socket = { encrypted: false, remoteAddress: "127.0.0.1" };
+    this.body = Buffer.from(packet.body || "", "base64");
+    this.sent = false;
+  }
+
+  _read() {
+    if (this.sent) return;
+    this.sent = true;
+    this.push(this.body);
+    this.push(null);
+  }
+}
+
+class RelayResponse extends Writable {
+  constructor() {
+    super();
+    this.statusCode = 200;
+    this.headers = new Map();
+    this.chunks = [];
+  }
+
+  setHeader(name, value) {
+    this.headers.set(name.toLowerCase(), Array.isArray(value) ? value.join(", ") : String(value));
+    return this;
+  }
+
+  getHeader(name) {
+    return this.headers.get(name.toLowerCase());
+  }
+
+  getHeaders() {
+    return Object.fromEntries(this.headers);
+  }
+
+  hasHeader(name) {
+    return this.headers.has(name.toLowerCase());
+  }
+
+  removeHeader(name) {
+    this.headers.delete(name.toLowerCase());
+  }
+
+  writeHead(status, headers) {
+    this.statusCode = status;
+    if (headers) for (const [name, value] of Object.entries(headers)) this.setHeader(name, value);
+    return this;
+  }
+
+  flushHeaders() {}
+
+  _write(chunk, _encoding, callback) {
+    this.chunks.push(Buffer.from(chunk));
+    callback();
+  }
+
+  body() {
+    return Buffer.concat(this.chunks);
+  }
+}
+
+function middlewareResponse(response) {
+  const body = response.body();
+  if (body.byteLength > MAX_BODY_BYTES) throw new Error("response body is too large");
+  return {
+    type: "http_response",
+    request_id: response.requestId,
+    status: response.statusCode,
+    headers: response.getHeaders(),
+    body: body.toString("base64")
+  };
+}
+
+async function handleRequest(server, packet, send) {
+  const request = new RelayRequest(packet);
+  const response = new RelayResponse();
+  response.requestId = packet.request_id;
+  await new Promise((resolveRequest, rejectRequest) => {
+    response.once("finish", resolveRequest);
+    response.once("error", rejectRequest);
+    try {
+      server.middlewares(request, response, () => {
+        if (!response.writableEnded) {
+          response.statusCode = 404;
+          response.end("Not found");
+        }
+      });
+    } catch (cause) {
+      rejectRequest(cause);
+    }
+  });
+  send(middlewareResponse(response));
+}
+
+function options(args) {
+  let root;
+  for (const argument of args) {
+    if (argument.startsWith("-")) throw new Error(`unknown option: ${argument}`);
+    if (root !== undefined) throw new Error("only one directory may be provided");
+    root = resolve(argument);
+  }
+  root = root || process.cwd();
+  if (!existsSync(root) || !statSync(root).isDirectory()) throw new Error(`directory does not exist: ${root}`);
+  return { root };
+}
+
+function endpoint(control, credential, sessionUrl) {
+  const url = new URL(control);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = "/v1/connect";
+  url.search = "";
+  url.hash = "";
+  if (credential && sessionUrl) {
+    const publicUrl = new URL(sessionUrl);
+    const hostCode = publicUrl.hostname.match(/^([a-f0-9]{20})\.letmeknow\.dev$/);
+    const pathCode = publicUrl.pathname.match(/^\/s\/([a-f0-9]{20})(?:\/|$)/);
+    const code = hostCode?.[1] || pathCode?.[1];
+    if (code) url.searchParams.set("code", code);
+  }
+  return url;
+}
+
+function validSessionUrl(value) {
+  if (typeof value !== "string") return false;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  if (/^[a-f0-9]{20}\.letmeknow\.dev$/.test(url.hostname)) return true;
+  return /^\/s\/[a-f0-9]{20}(?:\/|$)/.test(url.pathname);
+}
+
+async function start(args) {
+  const { root } = options(args);
+  const control = process.env.LETMEKNOW_URL || "https://letmeknow.dev";
+  let send = () => false;
+  const vite = await createServer({
+    root,
+    configFile: false,
+    appType: "spa",
+    css: { postcss: false },
+    logLevel: "silent",
+    server: { middlewareMode: true, hmr: false, ws: false, fs: { strict: true, allow: [root], deny: ["**/.env", "**/.env.*", "**/.git/**", "**/*.key", "**/*.pem", "**/*.p12", "**/*.sqlite", "**/*.db"] } },
+    plugins: [{
+      name: "letmeknow-relay",
+      resolveId(id) { return id === clientPath ? clientId : undefined; },
+      load(id) { return id === clientId ? client : undefined; },
+      configureServer(server) {
+        server.middlewares.use((request, response, next) => {
+          if (request.headers["x-letmeknow-submission"] !== "1") {
+            next();
+            return;
+          }
+          submission(request, response).catch(cause => {
+            response.statusCode = cause instanceof Error && cause.message === "submission is too large" ? 413 : 400;
+            response.setHeader("Content-Type", "text/plain; charset=utf-8");
+            response.end(cause instanceof Error ? cause.message : "invalid submission");
+          });
+        });
+        const update = file => send({ type: "file_update", path: "/" + relative(root, file).split(sep).join("/") });
+        server.watcher.on("change", update);
+        server.watcher.on("add", update);
+        server.watcher.on("unlink", update);
+      },
+      transformIndexHtml(html) {
+        const script = `<script type="module" src="${clientPath}" data-letmeknow-client></script>`;
+        return html.includes("</body>") ? html.replace("</body>", `${script}</body>`) : `${html}${script}`;
+      }
+    }]
+  });
+
+  let socket;
+  let credential;
+  let sessionUrl;
+  let retryTimer;
+  let connectionTimer;
+  let retryDelay = 100;
+  let retryUntil = 0;
+  let stopped = false;
+  let ready = false;
+  const stop = async code => {
+    if (stopped) return;
+    stopped = true;
+    clearTimeout(retryTimer);
+    clearTimeout(connectionTimer);
+    try { socket?.close(); } catch {}
+    await vite.close();
+    process.exit(code);
+  };
+  process.once("SIGINT", () => void stop(0));
+  process.once("SIGTERM", () => void stop(0));
+
+  const retry = () => {
+    if (stopped || Date.now() >= retryUntil) return void stop(1);
+    retryTimer = setTimeout(() => {
+      retryTimer = undefined;
+      connect();
+    }, retryDelay);
+    retryDelay = Math.min(retryDelay * 2, MAX_RETRY_DELAY);
+  };
+
+  const connect = () => {
+    if (stopped) return;
+    const reconnecting = Boolean(credential && sessionUrl);
+    const current = socket = reconnecting ? new WebSocket(endpoint(control, credential, sessionUrl), credential) : new WebSocket(endpoint(control));
+    connectionTimer = setTimeout(() => {
+      if (socket !== current || current.readyState === WebSocket.OPEN || stopped) return;
+      try { current.close(); } catch {}
+      if (reconnecting) retry(); else void stop(1);
+    }, CONNECTION_TIMEOUT);
+    current.addEventListener("open", () => {
+      if (socket !== current || stopped) return;
+      clearTimeout(connectionTimer);
+      retryDelay = 100;
+      if (reconnecting) retryUntil = 0;
+      send = packet => {
+        if (current.readyState !== WebSocket.OPEN) return false;
+        try { current.send(JSON.stringify(packet)); return true; } catch { return false; }
+      };
+      if (!reconnecting) send({ type: "open" });
+    });
+    current.addEventListener("message", event => {
+      if (typeof event.data !== "string") return;
+      let packet;
+      try { packet = JSON.parse(event.data); } catch { return; }
+      if (packet.type === "credential") {
+        if (typeof packet.credential !== "string" || !credentialPattern.test(packet.credential)) return void stop(1);
+        credential = packet.credential;
+      } else if (packet.type === "session") {
+        if (!validSessionUrl(packet.url)) return void stop(1);
+        sessionUrl = packet.url;
+        retryDelay = 100;
+        if (!ready) {
+          ready = true;
+          process.stdout.write(`${JSON.stringify({ type: "ready", url: sessionUrl })}\n`);
+        }
+      } else if (packet.type === "http_request") {
+        void handleRequest(vite, packet, response => send(response)).catch(() => send({ type: "http_response", request_id: packet.request_id, status: 500, headers: { "Content-Type": "text/plain; charset=utf-8" }, body: Buffer.from("preview request failed").toString("base64") }));
+      } else if (packet.type === "closed") {
+        void stop(0);
+      } else if (packet.type === "error") {
+        void stop(1);
+      }
+    });
+    current.addEventListener("error", () => {});
+    current.addEventListener("close", () => {
+      if (socket !== current || stopped) return;
+      clearTimeout(connectionTimer);
+      send = () => false;
+      socket = undefined;
+      if (!credential || !sessionUrl) return void stop(1);
+      if (!retryUntil) retryUntil = Date.now() + GRACE_SECONDS * 1_000;
+      retry();
+    });
+  };
+
+  connect();
+  await new Promise(() => {});
+}
 
 if (process.argv[2] === "--skill") {
   if (process.argv.length !== 3) {
@@ -8,13 +448,11 @@ if (process.argv[2] === "--skill") {
     process.exit(1);
   }
   writeSync(1, readFileSync(new URL("../SKILL.md", import.meta.url)));
-} else if (process.env.LETMEKNOW_URL && process.argv.length === 2) {
-  await import("./remote.js");
 } else if (process.argv.slice(2).includes("--help") || process.argv.slice(2).includes("-h")) {
-  process.stdout.write("Usage: npx letmeknow-cli [directory] [--port port]\n\nServe a folder through the hosted LetMeKnow relay. The CLI does not listen on a network port. Form submissions are JSON lines on stdout.\n");
+  process.stdout.write("Usage: npx letmeknow-cli [directory]\n\nServe a folder through the hosted LetMeKnow relay. The CLI does not listen on a network port. Form submissions are JSON lines on stdout.\n");
 } else {
   try {
-    await import("./relay.js");
+    await start(process.argv.slice(2));
   } catch (cause) {
     process.stderr.write(`letmeknow: ${cause instanceof Error ? cause.message : "server failed"}\n`);
     process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmeknow-cli",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "A live Vite preview with agent-readable form submissions.",
   "files": [
     "bin",

package/bin/relay.js

@@ -1,440 +0,0 @@
-import { createServer } from "vite";
-import { existsSync, statSync } from "node:fs";
-import { extname, relative, resolve, sep } from "node:path";
-import { Readable, Writable } from "node:stream";
-
-const MAX_BODY_BYTES = 1024 * 1024;
-const GRACE_SECONDS = 10 * 60;
-const CONNECTION_TIMEOUT = 10_000;
-const MAX_RETRY_DELAY = 5_000;
-const credentialPattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-const clientPath = "/__letmeknow_client.js";
-const clientId = "\0letmeknow-client";
-const client = String.raw`
-const key="letmeknow-client:"+location.host+location.pathname;
-const draftKey="letmeknow-draft:"+location.host+location.pathname;
-let credential=sessionStorage.getItem(key);
-let socket;
-let retryTimer;
-let terminal=false;
-const stateKey=(control,index)=>control.id?"#"+control.id:(control.form?.id??"")+":"+control.name+":"+control.type+":"+index;
-const controls=root=>[...root.querySelectorAll("input,select,textarea")];
-const snapshot=()=>{
-  const state=new Map();
-  let activeKey;
-  for(const [index,control] of controls(document).entries()){
-    const key=stateKey(control,index);
-    state.set(key,{value:control.value,checked:control.checked,selected:control instanceof HTMLSelectElement?[...control.options].filter(option=>option.selected).map(option=>option.value):undefined,start:typeof control.selectionStart==="number"?control.selectionStart:undefined,end:typeof control.selectionEnd==="number"?control.selectionEnd:undefined});
-    if(control===document.activeElement)activeKey=key;
-  }
-  return {state,activeKey,x:scrollX,y:scrollY};
-};
-const restore=saved=>{
-  let active;
-  for(const [index,control] of controls(document).entries()){
-    const state=saved.state.get(stateKey(control,index));
-    if(!state)continue;
-    if(control instanceof HTMLSelectElement&&state.selected)for(const option of control.options)option.selected=state.selected.includes(option.value);
-    else if(control.type==="checkbox"||control.type==="radio")control.checked=state.checked;
-    else{control.value=state.value;if(typeof state.start==="number"&&typeof control.setSelectionRange==="function")control.setSelectionRange(state.start,state.end)}
-    if(stateKey(control,index)===saved.activeKey)active=control;
-  }
-  active?.focus();
-  scrollTo(saved.x,saved.y);
-};
-const status=message=>{const element=document.querySelector("[data-letmeknow-status]");if(element)element.textContent=message};
-const sessionPrefix=location.pathname.match(/^\/s\/[a-f0-9]{20}\//)?.[0];
-const currentPath=()=>{const path=sessionPrefix?location.pathname.slice(sessionPrefix.length-1)||"/":location.pathname;return path.endsWith("/")?path+"index.html":path};
-const refresh=async()=>{
-  const saved=snapshot();
-  const response=await fetch(location.href,{cache:"no-store",headers:{Accept:"text/html"}});
-  if(!response.ok)throw new Error("page refresh failed");
-  const next=new DOMParser().parseFromString(await response.text(),"text/html");
-  document.title=next.title;
-  document.body.replaceChildren(...[...next.body.childNodes].filter(node=>!(node instanceof HTMLScriptElement&&node.hasAttribute("data-letmeknow-client"))));
-  const links=[...document.head.querySelectorAll("link[rel=stylesheet]")];
-  for(const link of links){const url=new URL(link.href);url.searchParams.set("_letmeknow",crypto.randomUUID());link.href=url}
-  restore(saved);
-};
-const update=path=>{if(path===currentPath()||path?.endsWith(".css"))refresh().catch(()=>status("The page could not be refreshed"))};
-const connect=()=>{
-  clearTimeout(retryTimer);retryTimer=undefined;
-  const url=new URL("_letmeknow/client",location.href);url.protocol=url.protocol==="https:"?"wss:":"ws:";
-  socket=credential?new WebSocket(url,credential):new WebSocket(url);
-  socket.onmessage=event=>{
-    const message=JSON.parse(event.data);
-    if(message.type==="credential"){credential=message.credential;sessionStorage.setItem(key,credential);return}
-    if(message.type==="challenge"){socket.send(JSON.stringify({type:"alive",nonce:message.nonce}));return}
-    if(message.type==="busy"){status("This session is open elsewhere");retryTimer=setTimeout(connect,message.retry_after*1000);return}
-    if(message.type==="file_update"){update(message.path);return}
-    if(message.type==="closed"){terminal=true;sessionStorage.removeItem(key);sessionStorage.removeItem(draftKey);status(message.message)}
-  };
-  socket.onclose=()=>{if(!terminal&&!retryTimer){status("Reconnecting…");retryTimer=setTimeout(connect,1000)}};
-  socket.onerror=()=>{};
-};
-document.addEventListener("submit",async event=>{
-  const form=event.target;
-  if(!(form instanceof HTMLFormElement))return;
-  event.preventDefault();
-  const submitter=event.submitter;
-  const method=(submitter?.getAttribute("formmethod")??form.getAttribute("method")??"get").toLowerCase();
-  if(method!=="get"&&method!=="post"){status("Only GET and POST forms are supported");return}
-  if(!form.checkValidity()){form.reportValidity();return}
-  let target;
-  try{target=new URL(submitter?.getAttribute("formaction")??form.getAttribute("action")??location.href,location.href)}catch{status("Invalid form action");return}
-  if(target.origin!==location.origin){status("Form actions must stay on this site");return}
-  if(sessionPrefix&&!target.pathname.startsWith(sessionPrefix))target.pathname=sessionPrefix+target.pathname;
-  const values=new URLSearchParams();
-  for(const [name,value] of new FormData(form,submitter)){if(typeof value!=="string"){status("File inputs are not supported");return}values.append(name,value)}
-  const metadata={id:crypto.randomUUID(),form_id:form.id||null,action:target.pathname+target.search,trigger:{id:submitter?.id||null,name:submitter?.getAttribute("name"),value:submitter?.getAttribute("value")}};
-  const headers={"X-LetMeKnow-Submission":"1","X-LetMeKnow-ID":encodeURIComponent(metadata.id),"X-LetMeKnow-Form-ID":encodeURIComponent(metadata.form_id??""),"X-LetMeKnow-Action":encodeURIComponent(metadata.action),"X-LetMeKnow-Trigger-ID":encodeURIComponent(metadata.trigger.id??""),"X-LetMeKnow-Trigger-Name":encodeURIComponent(metadata.trigger.name??""),"X-LetMeKnow-Trigger-Value":encodeURIComponent(metadata.trigger.value??"")};
-  if(method==="get")for(const [name,value] of values)target.searchParams.append(name,value);
-  try{const response=await fetch(target,{method:method.toUpperCase(),headers,...(method==="post"?{body:values}:{})});if(!response.ok)throw new Error();status("Submitted")}catch{status("The submission failed")}
-});
-connect();
-`;
-
-function encodedHeader(request, name) {
-  const value = request.headers[name];
-  if (typeof value !== "string" || value === "") return null;
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return null;
-  }
-}
-
-function addValue(values, name, value) {
-  if (Object.prototype.hasOwnProperty.call(values, name)) {
-    values[name] = Array.isArray(values[name]) ? [...values[name], value] : [values[name], value];
-  } else {
-    values[name] = value;
-  }
-}
-
-function readBody(request) {
-  return new Promise((resolveBody, reject) => {
-    const chunks = [];
-    let size = 0;
-    let tooLarge = false;
-    request.on("data", chunk => {
-      if (tooLarge) return;
-      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      size += buffer.byteLength;
-      if (size > MAX_BODY_BYTES) {
-        tooLarge = true;
-        request.resume();
-        reject(new Error("submission is too large"));
-        return;
-      }
-      chunks.push(buffer);
-    });
-    request.on("end", () => resolveBody(Buffer.concat(chunks)));
-    request.on("error", reject);
-  });
-}
-
-async function submission(request, response) {
-  const url = new URL(request.url || "/", "http://localhost");
-  const method = (request.method || "GET").toUpperCase();
-  const values = Object.create(null);
-  if (method === "GET") {
-    for (const [name, value] of url.searchParams) addValue(values, name, value);
-  } else if (method === "POST") {
-    const body = await readBody(request);
-    const contentType = request.headers["content-type"]?.split(";", 1)[0].trim();
-    if (contentType !== "application/x-www-form-urlencoded") throw new Error("unsupported submission encoding");
-    for (const [name, value] of new URLSearchParams(body.toString("utf8"))) addValue(values, name, value);
-  } else {
-    throw new Error("unsupported submission method");
-  }
-  const event = {
-    type: "submit",
-    id: encodedHeader(request, "x-letmeknow-id"),
-    method,
-    action: encodedHeader(request, "x-letmeknow-action") || url.pathname,
-    form_id: encodedHeader(request, "x-letmeknow-form-id"),
-    trigger: {
-      id: encodedHeader(request, "x-letmeknow-trigger-id"),
-      name: encodedHeader(request, "x-letmeknow-trigger-name"),
-      value: encodedHeader(request, "x-letmeknow-trigger-value")
-    },
-    values
-  };
-  process.stdout.write(`${JSON.stringify(event)}\n`);
-  response.statusCode = 204;
-  response.setHeader("Cache-Control", "no-store");
-  response.end();
-}
-
-class RelayRequest extends Readable {
-  constructor(packet) {
-    super();
-    this.method = packet.method;
-    this.url = packet.path;
-    this.originalUrl = packet.path;
-    this.headers = packet.headers || {};
-    this.httpVersion = "1.1";
-    this.httpVersionMajor = 1;
-    this.httpVersionMinor = 1;
-    this.socket = { encrypted: false, remoteAddress: "127.0.0.1" };
-    this.body = Buffer.from(packet.body || "", "base64");
-    this.sent = false;
-  }
-
-  _read() {
-    if (this.sent) return;
-    this.sent = true;
-    this.push(this.body);
-    this.push(null);
-  }
-}
-
-class RelayResponse extends Writable {
-  constructor() {
-    super();
-    this.statusCode = 200;
-    this.headers = new Map();
-    this.chunks = [];
-  }
-
-  setHeader(name, value) {
-    this.headers.set(name.toLowerCase(), Array.isArray(value) ? value.join(", ") : String(value));
-    return this;
-  }
-
-  getHeader(name) {
-    return this.headers.get(name.toLowerCase());
-  }
-
-  getHeaders() {
-    return Object.fromEntries(this.headers);
-  }
-
-  hasHeader(name) {
-    return this.headers.has(name.toLowerCase());
-  }
-
-  removeHeader(name) {
-    this.headers.delete(name.toLowerCase());
-  }
-
-  writeHead(status, headers) {
-    this.statusCode = status;
-    if (headers) for (const [name, value] of Object.entries(headers)) this.setHeader(name, value);
-    return this;
-  }
-
-  flushHeaders() {}
-
-  _write(chunk, _encoding, callback) {
-    this.chunks.push(Buffer.from(chunk));
-    callback();
-  }
-
-  body() {
-    return Buffer.concat(this.chunks);
-  }
-}
-
-function middlewareResponse(response) {
-  const body = response.body();
-  if (body.byteLength > MAX_BODY_BYTES) throw new Error("response body is too large");
-  return {
-    type: "http_response",
-    request_id: response.requestId,
-    status: response.statusCode,
-    headers: response.getHeaders(),
-    body: body.toString("base64")
-  };
-}
-
-async function handleRequest(server, packet, send) {
-  const request = new RelayRequest(packet);
-  const response = new RelayResponse();
-  response.requestId = packet.request_id;
-  await new Promise((resolveRequest, rejectRequest) => {
-    response.once("finish", resolveRequest);
-    response.once("error", rejectRequest);
-    try {
-      server.middlewares(request, response, () => {
-        if (!response.writableEnded) {
-          response.statusCode = 404;
-          response.end("Not found");
-        }
-      });
-    } catch (cause) {
-      rejectRequest(cause);
-    }
-  });
-  send(middlewareResponse(response));
-}
-
-function options(args) {
-  let root;
-  for (const argument of args) {
-    if (argument.startsWith("-")) throw new Error(`unknown option: ${argument}`);
-    if (root !== undefined) throw new Error("only one directory may be provided");
-    root = resolve(argument);
-  }
-  root = root || process.cwd();
-  if (!existsSync(root) || !statSync(root).isDirectory()) throw new Error(`directory does not exist: ${root}`);
-  return { root };
-}
-
-function endpoint(control, credential, sessionUrl) {
-  const url = new URL(control);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.pathname = "/v1/connect";
-  url.search = "";
-  url.hash = "";
-  if (credential && sessionUrl) {
-    const publicUrl = new URL(sessionUrl);
-    const hostCode = publicUrl.hostname.match(/^([a-f0-9]{20})\.letmeknow\.dev$/);
-    const pathCode = publicUrl.pathname.match(/^\/s\/([a-f0-9]{20})(?:\/|$)/);
-    const code = hostCode?.[1] || pathCode?.[1];
-    if (code) url.searchParams.set("code", code);
-  }
-  return url;
-}
-
-function validSessionUrl(value) {
-  if (typeof value !== "string") return false;
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    return false;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-  if (/^[a-f0-9]{20}\.letmeknow\.dev$/.test(url.hostname)) return true;
-  return /^\/s\/[a-f0-9]{20}(?:\/|$)/.test(url.pathname);
-}
-
-async function start(args) {
-  const { root } = options(args);
-  const control = process.env.LETMEKNOW_URL || "https://letmeknow.dev";
-  let send = () => false;
-  const vite = await createServer({
-    root,
-    configFile: false,
-    appType: "spa",
-    css: { postcss: false },
-    logLevel: "silent",
-    server: { middlewareMode: true, hmr: false, ws: false, fs: { strict: true, allow: [root], deny: ["**/.env", "**/.env.*", "**/.git/**", "**/*.key", "**/*.pem", "**/*.p12", "**/*.sqlite", "**/*.db"] } },
-    plugins: [{
-      name: "letmeknow-relay",
-      resolveId(id) { return id === clientPath ? clientId : undefined; },
-      load(id) { return id === clientId ? client : undefined; },
-      configureServer(server) {
-        server.middlewares.use((request, response, next) => {
-          if (request.headers["x-letmeknow-submission"] !== "1") {
-            next();
-            return;
-          }
-          submission(request, response).catch(cause => {
-            response.statusCode = cause instanceof Error && cause.message === "submission is too large" ? 413 : 400;
-            response.setHeader("Content-Type", "text/plain; charset=utf-8");
-            response.end(cause instanceof Error ? cause.message : "invalid submission");
-          });
-        });
-        const update = file => send({ type: "file_update", path: "/" + relative(root, file).split(sep).join("/") });
-        server.watcher.on("change", update);
-        server.watcher.on("add", update);
-        server.watcher.on("unlink", update);
-      },
-      transformIndexHtml(html) {
-        const script = `<script type="module" src="${clientPath}" data-letmeknow-client></script>`;
-        return html.includes("</body>") ? html.replace("</body>", `${script}</body>`) : `${html}${script}`;
-      }
-    }]
-  });
-
-  let socket;
-  let credential;
-  let sessionUrl;
-  let retryTimer;
-  let connectionTimer;
-  let retryDelay = 100;
-  let retryUntil = 0;
-  let stopped = false;
-  let ready = false;
-  const stop = async code => {
-    if (stopped) return;
-    stopped = true;
-    clearTimeout(retryTimer);
-    clearTimeout(connectionTimer);
-    try { socket?.close(); } catch {}
-    await vite.close();
-    process.exit(code);
-  };
-  process.once("SIGINT", () => void stop(0));
-  process.once("SIGTERM", () => void stop(0));
-
-  const retry = () => {
-    if (stopped || Date.now() >= retryUntil) return void stop(1);
-    retryTimer = setTimeout(() => {
-      retryTimer = undefined;
-      connect();
-    }, retryDelay);
-    retryDelay = Math.min(retryDelay * 2, MAX_RETRY_DELAY);
-  };
-
-  const connect = () => {
-    if (stopped) return;
-    const reconnecting = Boolean(credential && sessionUrl);
-    const current = socket = reconnecting ? new WebSocket(endpoint(control, credential, sessionUrl), credential) : new WebSocket(endpoint(control));
-    connectionTimer = setTimeout(() => {
-      if (socket !== current || current.readyState === WebSocket.OPEN || stopped) return;
-      try { current.close(); } catch {}
-      if (reconnecting) retry(); else void stop(1);
-    }, CONNECTION_TIMEOUT);
-    current.addEventListener("open", () => {
-      if (socket !== current || stopped) return;
-      clearTimeout(connectionTimer);
-      retryDelay = 100;
-      if (reconnecting) retryUntil = 0;
-      send = packet => {
-        if (current.readyState !== WebSocket.OPEN) return false;
-        try { current.send(JSON.stringify(packet)); return true; } catch { return false; }
-      };
-      if (!reconnecting) send({ type: "open", mode: "proxy" });
-    });
-    current.addEventListener("message", event => {
-      if (typeof event.data !== "string") return;
-      let packet;
-      try { packet = JSON.parse(event.data); } catch { return; }
-      if (packet.type === "credential") {
-        if (typeof packet.credential !== "string" || !credentialPattern.test(packet.credential)) return void stop(1);
-        credential = packet.credential;
-      } else if (packet.type === "session") {
-        if (!validSessionUrl(packet.url)) return void stop(1);
-        sessionUrl = packet.url;
-        retryDelay = 100;
-        if (!ready) {
-          ready = true;
-          process.stdout.write(`${JSON.stringify({ type: "ready", url: sessionUrl })}\n`);
-        }
-      } else if (packet.type === "http_request") {
-        void handleRequest(vite, packet, response => send(response)).catch(() => send({ type: "http_response", request_id: packet.request_id, status: 500, headers: { "Content-Type": "text/plain; charset=utf-8" }, body: Buffer.from("preview request failed").toString("base64") }));
-      } else if (packet.type === "closed") {
-        void stop(0);
-      }
-    });
-    current.addEventListener("error", () => {});
-    current.addEventListener("close", () => {
-      if (socket !== current || stopped) return;
-      clearTimeout(connectionTimer);
-      send = () => false;
-      socket = undefined;
-      if (!credential || !sessionUrl) return void stop(1);
-      if (!retryUntil) retryUntil = Date.now() + GRACE_SECONDS * 1_000;
-      retry();
-    });
-  };
-
-  connect();
-  await new Promise(() => {});
-}
-
-await start(process.argv.slice(2));

package/bin/remote.js

@@ -1,299 +0,0 @@
-#!/usr/bin/env node
-
-import { readFileSync, writeSync } from "node:fs";
-import readline from "node:readline";
-
-if (process.argv[2] === "--skill") {
-  if (process.argv.length !== 3) {
-    process.stderr.write("Usage: npx letmeknow-cli --skill\n");
-    process.exit(1);
-  }
-  writeSync(1, readFileSync(new URL("../SKILL.md", import.meta.url)));
-  process.exit(0);
-}
-
-const control = new URL(process.env.LETMEKNOW_URL || "https://letmeknow.dev");
-const graceSeconds = 10 * 60;
-const connectionAttemptTimeout = 10_000;
-const maxRetryDelay = 5_000;
-const subprotocolTokenPattern = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-let socket;
-let input;
-let credential;
-let sessionUrl;
-let retryTimer;
-let connectionTimer;
-let retryDelay = 100;
-let stdinClosed = false;
-let signalRequested = false;
-let explicitSessionClosed = false;
-let closeCommandAccepted = false;
-let closeCommandSent = false;
-let retryUntil = 0;
-let connected = false;
-let finished = false;
-const queued = [];
-
-function endpoint() {
-  const url = new URL(control);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.pathname = "/v1/connect";
-  url.search = "";
-  url.hash = "";
-  if (credential && sessionUrl) {
-    const publicUrl = new URL(sessionUrl);
-    const hostCode = publicUrl.hostname.match(/^([a-f0-9]{20})\.letmeknow\.dev$/);
-    const pathCode = publicUrl.pathname.match(/^\/s\/([a-f0-9]{20})(?:\/|$)/);
-    const code = hostCode?.[1] || pathCode?.[1];
-    if (code) {
-      url.searchParams.set("code", code);
-    }
-  }
-  return url;
-}
-
-function clearConnectionTimer() {
-  if (connectionTimer) clearTimeout(connectionTimer);
-  connectionTimer = undefined;
-}
-
-function finish(code) {
-  if (finished) return;
-  finished = true;
-  if (retryTimer) clearTimeout(retryTimer);
-  clearConnectionTimer();
-  input?.close();
-  process.exitCode = code;
-}
-
-function validCredential(value) {
-  return typeof value === "string" && subprotocolTokenPattern.test(value);
-}
-
-function validSessionUrl(value) {
-  if (typeof value !== "string") return false;
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    return false;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-  if (/^[a-f0-9]{20}\.letmeknow\.dev$/.test(url.hostname)) return true;
-  return /^\/s\/[a-f0-9]{20}(?:\/|$)/.test(url.pathname);
-}
-
-function isCloseCommand(line) {
-  try {
-    const packet = JSON.parse(line);
-    return packet !== null
-      && typeof packet === "object"
-      && !Array.isArray(packet)
-      && packet.type === "close"
-      && (packet.id === undefined || typeof packet.id === "string");
-  } catch {
-    return false;
-  }
-}
-
-function send(line) {
-  if (!socket || !connected || socket.readyState !== WebSocket.OPEN) return false;
-  try {
-    socket.send(line);
-    if (isCloseCommand(line)) closeCommandSent = true;
-    return true;
-  } catch {
-    try {
-      socket.close();
-    } catch {
-      // The close event still determines whether reconnect is needed.
-    }
-    return false;
-  }
-}
-
-function sendOrQueue(line) {
-  if (finished || closeCommandAccepted) return;
-  if (isCloseCommand(line)) closeCommandAccepted = true;
-  if (!send(line)) queued.push(line);
-}
-
-function flush() {
-  if (finished) return;
-  while (queued.length && !closeCommandSent) {
-    if (!send(queued[0])) break;
-    queued.shift();
-  }
-  if (closeCommandSent) queued.length = 0;
-  if (!queued.length && stdinClosed && !closeCommandSent && socket && connected) {
-    socket.close(1000, "stdin closed");
-  }
-}
-
-function protocolFailure(message) {
-  if (finished) return;
-  process.stderr.write(`letmeknow: server protocol error: ${message}\n`);
-  const current = socket;
-  if (current) {
-    try {
-      current.close(1000, "protocol error");
-    } catch {
-      // The process still exits below.
-    }
-  }
-  finish(1);
-}
-
-function handleMessage(event) {
-  if (finished) return;
-  if (typeof event.data !== "string") {
-    protocolFailure("binary WebSocket frame");
-    return;
-  }
-  const text = event.data;
-  let packet;
-  try {
-    packet = JSON.parse(text);
-  } catch {
-    protocolFailure("invalid JSON");
-    return;
-  }
-  if (!packet || typeof packet !== "object" || Array.isArray(packet)) {
-    protocolFailure("packet must be a JSON object");
-    return;
-  }
-  if (typeof packet.type !== "string") {
-    protocolFailure("packet type is required");
-    return;
-  }
-  if (packet.type === "credential") {
-    if (!validCredential(packet.credential)) {
-      protocolFailure("invalid credential");
-      return;
-    }
-    credential = packet.credential;
-    return;
-  }
-  if (packet.type === "session") {
-    if (!validSessionUrl(packet.url)) {
-      protocolFailure("invalid session URL");
-      return;
-    }
-    if (typeof packet.expires_after_disconnect !== "number"
-      || !Number.isFinite(packet.expires_after_disconnect)
-      || packet.expires_after_disconnect <= 0) {
-      protocolFailure("invalid session expiration");
-      return;
-    }
-    sessionUrl = packet.url;
-    retryDelay = 100;
-  }
-  if (packet.type === "closing") explicitSessionClosed = true;
-  process.stdout.write(`${text}\n`);
-}
-
-function retry() {
-  if (finished || signalRequested || explicitSessionClosed || closeCommandSent || (stdinClosed && !queued.length) || Date.now() >= retryUntil) {
-    finish(explicitSessionClosed || signalRequested || closeCommandSent || (stdinClosed && !queued.length) ? 0 : 1);
-    return;
-  }
-  retryTimer = setTimeout(() => {
-    retryTimer = undefined;
-    start();
-  }, retryDelay);
-  retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
-}
-
-function start() {
-  if (finished || signalRequested || explicitSessionClosed || closeCommandSent) return;
-  const reconnecting = Boolean(credential && sessionUrl);
-  const current = socket = reconnecting
-    ? new WebSocket(endpoint(), credential)
-    : new WebSocket(endpoint());
-  connectionTimer = setTimeout(() => {
-    if (socket !== current || connected || finished) return;
-    clearConnectionTimer();
-    process.stderr.write("letmeknow: WebSocket connection attempt timed out\n");
-    try {
-      current.close();
-    } catch {
-      // The close event is not available when construction failed.
-    }
-    socket = undefined;
-    connected = false;
-    if (reconnecting) retry();
-    else finish(1);
-  }, connectionAttemptTimeout);
-  current.addEventListener("message", handleMessage);
-  current.addEventListener("error", () => {
-    if (!finished) process.stderr.write("letmeknow: WebSocket connection failed; retrying\n");
-  });
-  current.addEventListener("open", () => {
-    if (socket !== current || finished) return;
-    clearConnectionTimer();
-    connected = true;
-    retryDelay = 100;
-    if (reconnecting) retryUntil = 0;
-    flush();
-  });
-  current.addEventListener("close", (event) => {
-    if (socket !== current) return;
-    clearConnectionTimer();
-    connected = false;
-    if (finished) return;
-    socket = undefined;
-    if (closeCommandSent || signalRequested || explicitSessionClosed || (stdinClosed && !queued.length)) {
-      finish(0);
-      return;
-    }
-    if (!credential || !sessionUrl) {
-      process.stderr.write(`letmeknow: connection closed (${event.code}${event.reason ? `: ${event.reason}` : ""})\n`);
-      finish(1);
-      return;
-    }
-    if (!retryUntil) retryUntil = Date.now() + graceSeconds * 1_000;
-    retry();
-  });
-}
-
-input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
-input.on("line", (line) => {
-  if (!finished && line.trim() && !closeCommandAccepted) sendOrQueue(line);
-});
-input.on("close", () => {
-  if (finished) return;
-  stdinClosed = true;
-  if (!socket) {
-    if (!queued.length) finish(0);
-    return;
-  }
-  if (connected) flush();
-  else if (!queued.length) {
-    const current = socket;
-    clearConnectionTimer();
-    try {
-      current.close();
-    } catch {
-      // The process still exits below.
-    }
-    socket = undefined;
-    finish(0);
-  }
-});
-
-for (const signal of ["SIGINT", "SIGTERM"]) {
-  process.on(signal, () => {
-    signalRequested = true;
-    clearConnectionTimer();
-    if (socket) {
-      try {
-        socket.close(1000, signal);
-      } catch {
-        // The process still exits below.
-      }
-    }
-    finish(0);
-  });
-}
-
-start();