Files
luxe/crates/luxe-remote/app/folders.js
Evan Whittaker d2129a886f Luxe 0.1.3: your sessions on your phone, joinable sessions, and nested AGENTS.md
- luxe remote puts the sessions on your computer in reach of your own phone or tablet over
  Tailscale: write, steer, answer prompts, send photos, browse files, diffs and GitHub, with a
  paired device and your own Tailscale login.
- luxe join lets another program on the same machine join a running session over the RPC protocol.
- An AGENTS.md in a subfolder reaches the model the first time it works there.
- Long sessions stay fast: no stall before each model call, lighter memory, cheaper drawing.
- A session is open in one Luxe at a time, web_search shares results across its phrasings, and a
  grep glob starting with ! excludes.

The CHANGELOG has the full list.
2026-10-20 02:40:13 -05:00

136 lines
5.4 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// @ts-check
// Starting a session: a page of its own, with the folders you've worked in narrowed by what you
// type, and any other folder you type.
//
// The bridge answers a start once the session can be joined, which takes a few seconds, so the
// page says which folder it's starting in meanwhile and opens the session when it's ready.
import { signal } from "@preact/signals";
import { useEffect, useState } from "preact/hooks";
import { fieldOf, html } from "./html.js";
/**
* A place a session can start, as `GET /api/folders` lists it.
* @typedef {{ path: string, name: string, sessions: number }} Folder
* @typedef {{ folders: Folder[], herdr: boolean }} Folders
*/
/** @type {import("@preact/signals").Signal<Folders | null>} */
const folders = signal(null);
/** Whether this bridge starts sessions at all; one run without a launcher says not. */
export const offered = signal(true);
const starting = signal("");
const problem = signal("");
/** Reads the folders again. @param {typeof fetch} get */
export async function refreshFolders(get = fetch) {
const response = await get("/api/folders");
if (response.status === 501) offered.value = false;
if (!response.ok) return;
folders.value = await response.json();
}
/**
* Starts a session in `folder`, resolving to its id once it can be joined; the host's reason
* when it can't. @param {string} folder @param {typeof fetch} post
*/
export async function startIn(folder, post = fetch) {
const response = await post("/api/sessions", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ folder }),
});
if (!response.ok) throw new Error((await response.text()) || `starting failed: ${response.status}`);
return (await response.json()).session.session_id;
}
/**
* The folders `typed` could mean, best first: a name that starts with it, then a name holding it,
* then a path holding it; nothing typed starts every name, so all of them come back in order.
* A leading `~/` is dropped, since the phone can't know which folder is home, and the rest still
* finds the path under it. @param {Folder[]} all @param {string} typed
*/
export function matchFolders(all, typed) {
const needle = typed.trim().replace(/^~[\\/]?/, "").toLowerCase();
/** @param {Folder} folder */
const rank = (folder) => {
const name = folder.name.toLowerCase();
if (name.startsWith(needle)) return 0;
if (name.includes(needle)) return 1;
return folder.path.toLowerCase().includes(needle) ? 2 : 3;
};
const ranked = all.map((folder) => ({ folder, rank: rank(folder) })).filter((entry) => entry.rank < 3);
return ranked.sort((a, b) => a.rank - b.rank).map((entry) => entry.folder);
}
/** @param {string} folder */
async function start(folder) {
starting.value = folder;
problem.value = "";
try {
location.hash = `#/session/${encodeURIComponent(await startIn(folder))}`;
} catch (error) {
problem.value = /** @type {Error} */ (error).message;
} finally {
starting.value = "";
}
}
export function NewSession() {
const [typed, setTyped] = useState("");
useEffect(() => {
refreshFolders().catch((error) => (problem.value = `couldn't read the folders: ${error}`));
}, []);
return html`
<header class="bar"><a class="back" href="#/" aria-label="Sessions">‹</a><span class="title">New session</span></header>
<main class="new-session">
<${FolderField} typed=${typed} setTyped=${setTyped} />
${problem.value ? html`<p class="problem">${problem.value}</p>` : null}
<${Where} />
<${Suggestions} typed=${typed} />
</main>`;
}
/** @param {{ typed: string, setTyped: (typed: string) => void }} props */
function FolderField({ typed, setTyped }) {
const asked = typed.trim();
/** @param {SubmitEvent} event */
const submit = (event) => {
event.preventDefault();
if (asked) start(asked);
};
return html`<form class="other-folder" onSubmit=${submit}>
<input type="text" placeholder="Folder path, like ~/code/app" value=${typed} autocapitalize="off"
autocorrect="off" spellcheck="false" enterkeyhint="go" aria-label="Folder"
onInput=${(/** @type {Event} */ event) => setTyped(fieldOf(event).value)} />
<button type="submit" disabled=${!asked || starting.value !== ""}>
${starting.value === asked && asked ? "Starting…" : "Start"}</button>
</form>`;
}
function Where() {
if (!folders.value) return null;
const herdr = folders.value.herdr;
return html`<p class="dim">${herdr ? "Opens in a herdr pane on your computer." : "Runs until luxe remote stops."}</p>`;
}
/** @param {{ typed: string }} props */
function Suggestions({ typed }) {
if (!folders.value) return html`<p class="dim">Loading folders…</p>`;
const matched = matchFolders(folders.value.folders, typed);
if (!matched.length) return html`<p class="dim">${typed.trim() ? "No matching folders." : "No recent folders."}</p>`;
return html`<ul class="sessions">
${matched.map((folder) => html`<li key=${folder.path}><${FolderRow} folder=${folder} /></li>`)}
</ul>`;
}
/** @param {{ folder: Folder }} props */
function FolderRow({ folder }) {
const busy = starting.value !== "";
const running = folder.sessions ? ` · ${folder.sessions} running` : "";
return html`<button type="button" class="session folder" disabled=${busy} onClick=${() => start(folder.path)}>
<span class="name">${starting.value === folder.path ? `Starting in ${folder.name}…` : folder.name}</span>
<span class="dim path">${folder.path}${running}</span>
</button>`;
}