@gorlitzer-labs/seldon 0.12.0 → 0.14.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +72 -0
- package/bin/seldon.js +83 -7
- package/lib/serve.mjs +241 -0
- package/lib/telegram.mjs +89 -0
- package/lib/web/index.html +351 -0
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -134,6 +134,78 @@ seldon machines # each one, and whether it an
|
|
|
134
134
|
- **From a phone:** `ssh` to any one machine and run `seldon`. Below 70 columns it switches to
|
|
135
135
|
one line per lane.
|
|
136
136
|
|
|
137
|
+
## On your phone — `seldon serve`
|
|
138
|
+
|
|
139
|
+
The panel as a web app, for a phone (or any browser). Same lanes, same actions, a touch screen
|
|
140
|
+
instead of a terminal: what needs you first, the agent's screen, quick replies, stop / resume /
|
|
141
|
+
remove, new lanes and the plan, for this machine and every machine in `seldon machines`.
|
|
142
|
+
|
|
143
|
+
```bash
|
|
144
|
+
seldon serve # http://localhost:7930/#t=<token> on this machine only
|
|
145
|
+
seldon serve --tailnet # + HTTPS on your tailnet, for your tailscale login only
|
|
146
|
+
seldon serve --tailnet --owner you@example.com # a different login than this machine's
|
|
147
|
+
seldon serve --allow-reply # let the phone type into agents (off by default)
|
|
148
|
+
```
|
|
149
|
+
|
|
150
|
+
- **Nothing is open by default.** It listens on loopback only. `--tailnet` puts it behind
|
|
151
|
+
`tailscale serve` (HTTPS, tailnet-only, never the internet, on its own port 8443 so it never
|
|
152
|
+
takes `/` from the voice) and lets in exactly one login: `--owner`, or this machine's
|
|
153
|
+
tailscale user. If it can't tell whose it is, it does not go on the tailnet. Undo with
|
|
154
|
+
`tailscale serve --https=8443 off`.
|
|
155
|
+
- **A token on every call.** The first run makes one in `~/.seldon/serve-token` (0600). Every
|
|
156
|
+
API call, reads included, needs it; the phone gets it once from the link `serve` prints,
|
|
157
|
+
keeps it, and takes it out of the address bar. `rm ~/.seldon/serve-token` for a new one —
|
|
158
|
+
every device has to open the new link.
|
|
159
|
+
- **A leftover tailnet mapping reaches nothing.** Started without `--tailnet`, it refuses every
|
|
160
|
+
request that comes in by a `*.ts.net` name.
|
|
161
|
+
- **Replies are off unless `--allow-reply`,** and are a whitelist of keys or literal text. A
|
|
162
|
+
menu key ("1") is sent without Enter.
|
|
163
|
+
- **What it can read:** lanes in tmux (Codex, opencode, and Claude lanes seldon started) show
|
|
164
|
+
their screen and take replies. An interactive Claude session in a plain terminal has no pane
|
|
165
|
+
to read: open it with `claude attach`, or from the Claude app with Remote Control.
|
|
166
|
+
- **It acts with this machine's ssh keys:** a lane on another machine is stopped or started by
|
|
167
|
+
`ssh <machine> seldon lane …`, so whoever gets in reaches those machines' lanes too.
|
|
168
|
+
- **Alerts:** while the page is open, the phone buzzes and notifies when an agent starts
|
|
169
|
+
needing you.
|
|
170
|
+
|
|
171
|
+
## On Telegram — `seldon tell`
|
|
172
|
+
|
|
173
|
+
Any agent, on any machine, can message you — text, screenshots, videos, files — and the
|
|
174
|
+
watcher sends its news there too (needs you, failed, finished), so the phone hears about it
|
|
175
|
+
with the app closed.
|
|
176
|
+
|
|
177
|
+
```bash
|
|
178
|
+
seldon tell "the build is green" # text (long text is split)
|
|
179
|
+
pnpm test 2>&1 | tail -20 | seldon tell # or from stdin
|
|
180
|
+
seldon tell --file out/pitch.mp4 "first cut" # a file, with a caption
|
|
181
|
+
```
|
|
182
|
+
|
|
183
|
+
Images show inline, videos play, GIFs animate, audio plays, anything else is a document; a
|
|
184
|
+
bot can send up to 50 MB per file.
|
|
185
|
+
|
|
186
|
+
**Once:** make a bot with [@BotFather](https://t.me/BotFather), store its token in comb —
|
|
187
|
+
`comb set TELEGRAM_BOT_TOKEN` — send your bot `/start`, then `seldon tell --setup` (it finds
|
|
188
|
+
your chat and keeps its id in `~/.seldon/telegram.json`). Stored it under another name?
|
|
189
|
+
`seldon tell --setup --token-name MY_NAME` — seldon remembers it.
|
|
190
|
+
|
|
191
|
+
- **The token never shows.** seldon does not store it: without it in the environment,
|
|
192
|
+
`seldon tell` re-runs itself under `comb run --with TELEGRAM_BOT_TOKEN`, so an agent can send
|
|
193
|
+
without ever seeing it. Every machine with comb synced can send.
|
|
194
|
+
- **Sending only.** Any number of sessions can send through one bot. Writing *to* an agent from
|
|
195
|
+
Telegram (text, or a screenshot from your phone) is Claude Code's own Telegram channel
|
|
196
|
+
(`claude --channels plugin:telegram@claude-plugins-official`), and the same bot works for
|
|
197
|
+
both: sending never competes with its one reader. Run `seldon tell --setup` before starting
|
|
198
|
+
that channel — setup reads the bot's messages once to find your chat.
|
|
199
|
+
|
|
200
|
+
Tell your agents once, in `~/.claude/CLAUDE.md` / `AGENTS.md`:
|
|
201
|
+
|
|
202
|
+
```markdown
|
|
203
|
+
## Telegram
|
|
204
|
+
Send the operator what they'd want to see on their phone with `seldon tell "…"` /
|
|
205
|
+
`seldon tell --file <path> "caption"`: a finished piece of work, a screenshot or video of it,
|
|
206
|
+
a link, a blocker. Short. Never a secret.
|
|
207
|
+
```
|
|
208
|
+
|
|
137
209
|
## Holds — taking turns on shared things
|
|
138
210
|
|
|
139
211
|
Agents on different projects share one machine: one boots the Android emulator, another
|
package/bin/seldon.js
CHANGED
|
@@ -13,6 +13,8 @@ import { openCommand, stopCommand, transitions, laneForItem, slugify, HARNESSES
|
|
|
13
13
|
import { startLane, stopLane, resumeLane, removeLane, findLane } from "../lib/actions.mjs";
|
|
14
14
|
import { listMachines, addMachine, fetchLanes, remoteGroups, sshArgs, lastJsonLine } from "../lib/machines.mjs";
|
|
15
15
|
import { notify } from "../lib/notify.mjs";
|
|
16
|
+
import { serve, serveToken, ownerFromStatus } from "../lib/serve.mjs";
|
|
17
|
+
import { tokenName, readChat, writeChat, chatFromUpdates, getUpdates, sendText, sendFile } from "../lib/telegram.mjs";
|
|
16
18
|
import { reportFromEvent, mergeCodexHooks, removeCodexHooks, opencodePlugin } from "../lib/reports.mjs";
|
|
17
19
|
import { buildRows, headline, ago, laneDetail, unlistedAgents, GLYPH } from "../lib/home.mjs";
|
|
18
20
|
import { parseDuration, describe as describeHold, NAME_RE, DEFAULT_FOR_MS } from "../lib/holds.mjs";
|
|
@@ -523,11 +525,11 @@ function tailscaleBin() {
|
|
|
523
525
|
}
|
|
524
526
|
return null;
|
|
525
527
|
}
|
|
526
|
-
function
|
|
527
|
-
try {
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
528
|
+
function tailscaleStatus(ts) {
|
|
529
|
+
try { return JSON.parse(execSync(`${ts} status --json`, { stdio: ["ignore", "pipe", "ignore"], timeout: 15000 }).toString()); } catch { return null; }
|
|
530
|
+
}
|
|
531
|
+
function tailnetDnsName(ts, status = tailscaleStatus(ts)) {
|
|
532
|
+
return status ? ((status.Self && status.Self.DNSName) || "").replace(/\.$/, "") : null;
|
|
531
533
|
}
|
|
532
534
|
function tailscaleServeUrl() {
|
|
533
535
|
const ts = tailscaleBin(); if (!ts) return null;
|
|
@@ -1431,6 +1433,8 @@ ${C.bold("seldon")} — the agent factory: your projects, and the stack that run
|
|
|
1431
1433
|
Idempotent, and it prints every step it skipped. Run it from inside a repo.
|
|
1432
1434
|
${C.bold("seldon up")} start the stack (voice + supervisor) and print where to go
|
|
1433
1435
|
${C.bold("seldon up --tailnet")} expose the voice over HTTPS (tailscale serve) so the mic works on your phone
|
|
1436
|
+
${C.bold("seldon serve")} [--tailnet] the panel as a phone web app (--allow-reply to answer agents)
|
|
1437
|
+
${C.bold("seldon tell")} "…" message yourself on Telegram (--file to send one; --setup once)
|
|
1434
1438
|
${C.bold("seldon up --brain=X")} pick the voice brain: qwen (in-process) | bonsai (local server); remembered
|
|
1435
1439
|
${C.bold("seldon status")} what's running · ${C.bold("seldon down")} stop it
|
|
1436
1440
|
${C.bold("seldon adopt")} [dir] put an existing repo on the line: foundation docs (never overwritten),
|
|
@@ -1462,6 +1466,14 @@ ${C.bold("seldon")} — the agent factory: your projects, and the stack that run
|
|
|
1462
1466
|
const SELF = fileURLToPath(import.meta.url);
|
|
1463
1467
|
const startWatch = () => startDaemon("seldon-watch", process.execPath, [SELF, "watch"]);
|
|
1464
1468
|
|
|
1469
|
+
// The watcher's news on the phone too, once `seldon tell --setup` has been run. A child
|
|
1470
|
+
// `seldon tell` per event, so the token goes through comb exactly as it does for an agent.
|
|
1471
|
+
function tellInBackground(text) {
|
|
1472
|
+
if (process.env.SELDON_NO_NOTIFY || !readChat()) return;
|
|
1473
|
+
const child = spawn(process.execPath, [process.argv[1], "tell", text], { stdio: "ignore", detached: true });
|
|
1474
|
+
child.on("error", () => {}); child.unref();
|
|
1475
|
+
}
|
|
1476
|
+
|
|
1465
1477
|
async function watchCmd(flags) {
|
|
1466
1478
|
ensureSiblingPath();
|
|
1467
1479
|
const every = parseDuration(flags.interval, 5000) || 5000;
|
|
@@ -1473,7 +1485,9 @@ async function watchCmd(flags) {
|
|
|
1473
1485
|
try { lanes = readLanes().flatMap((g) => g.lanes); } catch (e) { console.log(`${stamp()} read failed: ${e.message}`); }
|
|
1474
1486
|
for (const e of transitions(prev, lanes)) {
|
|
1475
1487
|
console.log(`${stamp()} ${e.text}`);
|
|
1476
|
-
|
|
1488
|
+
const where = path.basename(e.lane.project || e.lane.cwd || "");
|
|
1489
|
+
notify(e.to === "needs-you" ? "Seldon · needs you" : "Seldon", `${e.text} — ${where}`);
|
|
1490
|
+
tellInBackground(`${e.to === "needs-you" ? "⚑" : e.to === "failed" ? "✗" : "✓"} ${e.text} — ${where}`);
|
|
1477
1491
|
}
|
|
1478
1492
|
prev = new Map(lanes.map((l) => [l.key, l.state]));
|
|
1479
1493
|
if (flags.once) return;
|
|
@@ -1527,6 +1541,66 @@ function laneCmd(verb, arg, flags) {
|
|
|
1527
1541
|
console.log(C.green(`✓ ${verb === "stop" ? "stopped" : "resumed"} ${lane.name}`) + (r.fresh ? C.dim(" (new conversation, same task + worktree)") : ""));
|
|
1528
1542
|
}
|
|
1529
1543
|
|
|
1544
|
+
// `seldon serve` — the panel for a phone. Loopback only, and every call needs the token.
|
|
1545
|
+
// `--tailnet` puts it behind `tailscale serve` (HTTPS, its own port so it never takes the
|
|
1546
|
+
// voice's /) and only ever for one login: --owner, or this machine's tailscale user.
|
|
1547
|
+
const SERVE_TAILNET_PORT = 8443;
|
|
1548
|
+
function serveCmd(flags) {
|
|
1549
|
+
const port = Number(flags.port) || 7930;
|
|
1550
|
+
const allowReply = !!flags["allow-reply"];
|
|
1551
|
+
const token = serveToken();
|
|
1552
|
+
let owner = null, dns = null, ts = null;
|
|
1553
|
+
if (flags.tailnet) {
|
|
1554
|
+
ts = tailscaleBin(); const status = ts && tailscaleStatus(ts);
|
|
1555
|
+
dns = tailnetDnsName(ts, status);
|
|
1556
|
+
owner = typeof flags.owner === "string" ? flags.owner : ownerFromStatus(status);
|
|
1557
|
+
if (!dns || !owner) { console.log(C.red(" not serving on the tailnet: " + (!dns ? "tailscale not found or not connected" : "can't tell whose it is — pass --owner you@example.com"))); process.exitCode = 1; return; }
|
|
1558
|
+
}
|
|
1559
|
+
serve({ port, token, owner, tailnet: !!flags.tailnet, allowReply });
|
|
1560
|
+
console.log(C.green(`✓ seldon serve`) + C.dim(` on http://localhost:${port}/#t=${token}`) + (allowReply ? C.gold(" · replies ON (the phone can type into agents)") : ""));
|
|
1561
|
+
if (!flags.tailnet) { console.log(C.dim(` for your phone: seldon serve --tailnet (HTTPS on your tailnet, only for your login)`)); return; }
|
|
1562
|
+
try {
|
|
1563
|
+
execSync(`${ts} serve --bg --https=${SERVE_TAILNET_PORT} http://127.0.0.1:${port}`, { stdio: "ignore", timeout: 30000 });
|
|
1564
|
+
console.log(C.green(` phone → https://${dns}:${SERVE_TAILNET_PORT}/#t=${token}`) + C.dim(` only for ${owner} · open it once, then add to home screen`));
|
|
1565
|
+
console.log(C.dim(` undo: tailscale serve --https=${SERVE_TAILNET_PORT} off · new token: rm ~/.seldon/serve-token`));
|
|
1566
|
+
} catch (e) { console.log(C.red(" tailscale serve failed: " + ((e.stderr || e.message || "").toString().split("\n")[0]))); }
|
|
1567
|
+
}
|
|
1568
|
+
|
|
1569
|
+
// `seldon tell "…"` — message the operator on Telegram, from any agent. The token comes from
|
|
1570
|
+
// comb in the environment: without it, seldon re-runs itself under `comb run`, so the value
|
|
1571
|
+
// is never in an argument, a file seldon writes, or the agent's transcript.
|
|
1572
|
+
async function tellCmd(words, flags) {
|
|
1573
|
+
const fail = (msg) => { console.error(C.red(msg)); process.exitCode = 1; };
|
|
1574
|
+
const name = typeof flags["token-name"] === "string" ? flags["token-name"] : tokenName();
|
|
1575
|
+
if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) return fail(`not a secret name: ${name}`);
|
|
1576
|
+
const token = process.env[name];
|
|
1577
|
+
if (!token) {
|
|
1578
|
+
if (process.env.SELDON_TELL_VIA_COMB) return fail(`comb has no ${name} — store it once: comb set ${name}`);
|
|
1579
|
+
if (!has("comb")) return fail(`no ${name} in the environment, and comb is not installed (seldon install comb)`);
|
|
1580
|
+
const r = spawnSync("comb", ["run", "--with", name, "--", process.execPath, process.argv[1], ...process.argv.slice(2)],
|
|
1581
|
+
{ stdio: "inherit", env: { ...process.env, SELDON_TELL_VIA_COMB: "1" } });
|
|
1582
|
+
process.exitCode = r.status ?? 1;
|
|
1583
|
+
return;
|
|
1584
|
+
}
|
|
1585
|
+
try {
|
|
1586
|
+
if (flags.setup) {
|
|
1587
|
+
const chat = chatFromUpdates(await getUpdates(token));
|
|
1588
|
+
if (!chat) return fail("no message to the bot yet — open your bot in Telegram, send it /start, then run this again");
|
|
1589
|
+
writeChat({ ...chat, ...(name !== "TELEGRAM_BOT_TOKEN" ? { tokenName: name } : {}) });
|
|
1590
|
+
await sendText(token, chat.id, "✓ seldon is connected. Agents can reach you here with: seldon tell \"…\"");
|
|
1591
|
+
return console.log(C.green(`✓ connected to ${chat.name || "your chat"}`) + C.dim(" — try: seldon tell \"hello\""));
|
|
1592
|
+
}
|
|
1593
|
+
const chat = readChat();
|
|
1594
|
+
if (!chat) return fail("not set up yet — send your bot /start in Telegram, then: seldon tell --setup");
|
|
1595
|
+
let text = words.join(" ");
|
|
1596
|
+
if (!text && !process.stdin.isTTY) { for await (const c of process.stdin) text += c; text = text.trim(); }
|
|
1597
|
+
if (typeof flags.file === "string") await sendFile(token, chat.id, flags.file, text);
|
|
1598
|
+
else if (text) await sendText(token, chat.id, text);
|
|
1599
|
+
else return fail('usage: seldon tell "message" · … | seldon tell · seldon tell --file shot.png "caption" · seldon tell --setup');
|
|
1600
|
+
console.log(C.green("✓ sent"));
|
|
1601
|
+
} catch (e) { fail(e.message); }
|
|
1602
|
+
}
|
|
1603
|
+
|
|
1530
1604
|
// `seldon machines` — the other computers the panel shows (bifrost's realms, one list).
|
|
1531
1605
|
function machinesCmd(verb, name, target) {
|
|
1532
1606
|
if (verb === "add") {
|
|
@@ -1653,7 +1727,7 @@ function holdsCmd() {
|
|
|
1653
1727
|
// (`--no-attach`). The value form has to be CONSUMED: filtering out everything starting with
|
|
1654
1728
|
// `--` and keeping the rest as positionals read `seldon go --agent claude` as the project
|
|
1655
1729
|
// named "claude".
|
|
1656
|
-
const VALUE_FLAGS = new Set(["agent", "model", "effort", "name", "port", "pm", "stall", "dir", "for", "wait", "as", "note", "interval", "task"]);
|
|
1730
|
+
const VALUE_FLAGS = new Set(["agent", "model", "effort", "name", "port", "pm", "stall", "dir", "for", "wait", "as", "note", "interval", "task", "owner", "file", "token-name"]);
|
|
1657
1731
|
function parseArgv(raw) {
|
|
1658
1732
|
const flags = {}, positional = [];
|
|
1659
1733
|
for (let i = 0; i < raw.length; i++) {
|
|
@@ -1707,6 +1781,8 @@ const ids = tokens.filter((id) => byId[id]); // only the valid module
|
|
|
1707
1781
|
if (cmd === "lanes") return lanesCmd(flags);
|
|
1708
1782
|
if (cmd === "machines") return machinesCmd(tokens[0], tokens[1], tokens[2]);
|
|
1709
1783
|
if (cmd === "lane") return laneCmd(tokens[0], tokens[1], flags);
|
|
1784
|
+
if (cmd === "serve") return serveCmd(flags);
|
|
1785
|
+
if (cmd === "tell") return tellCmd(tokens, flags);
|
|
1710
1786
|
if (cmd === "setup") return setupCmd(tokens[0], flags);
|
|
1711
1787
|
if (cmd === "panel" || cmd === "board") return panel();
|
|
1712
1788
|
if (cmd && cmd !== "install") { help(); process.exitCode = 1; return; }
|
package/lib/serve.mjs
ADDED
|
@@ -0,0 +1,241 @@
|
|
|
1
|
+
// `seldon serve` — the panel as a phone app. Same lanes, same actions, a touch screen instead of
|
|
2
|
+
// a terminal. It owns nothing: it reads what the panel reads (readLanes, bifrost's machines) and
|
|
3
|
+
// acts through the same functions `seldon lane …` uses, locally or over `ssh <machine> seldon …`.
|
|
4
|
+
//
|
|
5
|
+
// Reach it from a phone with `tailscale serve`: HTTPS, the tailnet's identity on every request,
|
|
6
|
+
// no port on the internet. On its own it listens on loopback only.
|
|
7
|
+
//
|
|
8
|
+
// Pure rules first (tested without a server), then the I/O.
|
|
9
|
+
import { createServer } from "node:http";
|
|
10
|
+
import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
|
|
11
|
+
import { randomBytes, timingSafeEqual } from "node:crypto";
|
|
12
|
+
import { execFile } from "node:child_process";
|
|
13
|
+
import { join, dirname } from "node:path";
|
|
14
|
+
import { fileURLToPath } from "node:url";
|
|
15
|
+
import { readLanes, readPlan, addToPlan, projectRoot, SELDON_HOME } from "./agents.mjs";
|
|
16
|
+
import { startLane, stopLane, resumeLane, removeLane, findLane, allLanes } from "./actions.mjs";
|
|
17
|
+
import { listMachines, fetchLanes, remoteGroups, sshArgs } from "./machines.mjs";
|
|
18
|
+
import { listHolds } from "./holds-store.mjs";
|
|
19
|
+
import { headline } from "./home.mjs";
|
|
20
|
+
import { HARNESSES, laneForItem, stopCommand, resumeCommands } from "./lanes.mjs";
|
|
21
|
+
|
|
22
|
+
const HERE = dirname(fileURLToPath(import.meta.url));
|
|
23
|
+
|
|
24
|
+
// ---- pure ---------------------------------------------------------------------------
|
|
25
|
+
// "mini/claude:ab12" → { machine: "mini", key: "claude:ab12" }; local keys have no slash.
|
|
26
|
+
export function splitKey(key) {
|
|
27
|
+
const s = String(key || "");
|
|
28
|
+
const i = s.indexOf("/");
|
|
29
|
+
return i > 0 && !s.slice(0, i).includes(":") ? { machine: s.slice(0, i), key: s.slice(i + 1) } : { machine: null, key: s };
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
// Who may talk to it:
|
|
33
|
+
// - the Host is loopback or a tailnet name (a DNS-rebinding page can pose as neither), and a
|
|
34
|
+
// tailnet name only when it was started with --tailnet (`tailnet`): a `tailscale serve`
|
|
35
|
+
// mapping left over from an earlier run reaches nothing;
|
|
36
|
+
// - on the tailnet, the login tailscale serve stamps on the request must be the owner;
|
|
37
|
+
// - every /api call, reads too, carries the token. That also stops cross-site pages: they
|
|
38
|
+
// can't read it, and can't set a custom header without a CORS preflight nobody answers.
|
|
39
|
+
// The page itself (/) is static and holds no data, so it loads without one.
|
|
40
|
+
export function guard({ path, host, headers }, { token, owner = null, tailnet = false } = {}) {
|
|
41
|
+
const h = String(host || "").replace(/:\d+$/, "").toLowerCase();
|
|
42
|
+
const local = h === "localhost" || h === "127.0.0.1" || h === "[::1]";
|
|
43
|
+
if (!local && !h.endsWith(".ts.net")) return "host not allowed";
|
|
44
|
+
if (!local && !tailnet) return "not served on the tailnet (start with: seldon serve --tailnet)";
|
|
45
|
+
if (!local && (!owner || headers["tailscale-user-login"] !== owner)) return "not the owner";
|
|
46
|
+
if (String(path).startsWith("/api/") && !tokenOk(headers["x-seldon-token"], token)) return "bad or missing token";
|
|
47
|
+
return null;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
export function tokenOk(given, token) {
|
|
51
|
+
if (!token || typeof given !== "string") return false;
|
|
52
|
+
const a = Buffer.from(given), b = Buffer.from(token);
|
|
53
|
+
return a.length === b.length && timingSafeEqual(a, b);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
// The tailnet login of this machine's user: who --tailnet lets in when --owner is not given.
|
|
57
|
+
export function ownerFromStatus(status) {
|
|
58
|
+
const id = status?.Self?.UserID;
|
|
59
|
+
return (id != null && status?.User?.[String(id)]?.LoginName) || null;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
// Keys a phone may press into an agent. A whitelist, so a reply can't smuggle tmux syntax.
|
|
63
|
+
export const REPLY_KEYS = { enter: "Enter", esc: "Escape", up: "Up", down: "Down", tab: "Tab", "ctrl-c": "C-c" };
|
|
64
|
+
// `submit: false` types without Enter: a menu key ("1") already chooses, and an Enter after it
|
|
65
|
+
// would answer whatever the agent asks next.
|
|
66
|
+
export function replyArgs(session, { key, text, submit = true } = {}) {
|
|
67
|
+
if (!session) return null;
|
|
68
|
+
if (key && REPLY_KEYS[key]) return [["send-keys", "-t", session, REPLY_KEYS[key]]];
|
|
69
|
+
if (typeof text === "string" && text.length && text.length <= 2000)
|
|
70
|
+
return [["send-keys", "-t", session, "-l", text], ...(submit ? [["send-keys", "-t", session, "Enter"]] : [])];
|
|
71
|
+
return null;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
// What a phone can do with a lane, so the UI never offers a button the server will refuse.
|
|
75
|
+
export function laneCaps(lane) {
|
|
76
|
+
const live = !["stopped", "failed"].includes(lane.state);
|
|
77
|
+
return {
|
|
78
|
+
peek: !!lane.tmuxSession && live,
|
|
79
|
+
reply: !!lane.tmuxSession && live,
|
|
80
|
+
stop: live && !stopCommand(lane).why,
|
|
81
|
+
resume: !live && !resumeCommands(lane).why,
|
|
82
|
+
rm: !live,
|
|
83
|
+
// Claude background lanes live under Claude's own supervisor: no tmux pane to read.
|
|
84
|
+
// Claude's Remote Control (claude.ai/code, the Claude app) is the way in for those.
|
|
85
|
+
hint: !lane.tmuxSession && lane.harness === "claude" && live
|
|
86
|
+
? (lane.id ? `claude attach ${lane.id}` : "open it in its terminal, or with Claude Remote Control") : null,
|
|
87
|
+
};
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
// ---- I/O ----------------------------------------------------------------------------
|
|
91
|
+
const sh = (bin, args, timeout = 10_000) => new Promise((res) =>
|
|
92
|
+
execFile(bin, args, { timeout, encoding: "utf8", maxBuffer: 4 << 20 }, (err, stdout, stderr) =>
|
|
93
|
+
res({ ok: !err, out: stdout || "", error: err ? (String(stderr).trim().split("\n").pop() || err.message) : null })));
|
|
94
|
+
|
|
95
|
+
// Machines are asked in the background, like the panel does, so a sleeping one never stalls a
|
|
96
|
+
// request. The cache is what the API answers from.
|
|
97
|
+
function remoteCache(intervalMs = 10_000) {
|
|
98
|
+
const state = new Map(); // name → { machine, lanes, error, at }
|
|
99
|
+
const poll = () => {
|
|
100
|
+
for (const m of listMachines()) fetchLanes(m, (r) => state.set(m.name, { machine: m, ...r, at: Date.now() }));
|
|
101
|
+
};
|
|
102
|
+
poll();
|
|
103
|
+
const t = setInterval(poll, intervalMs); t.unref();
|
|
104
|
+
return {
|
|
105
|
+
groups: () => [...state.values()].filter((s) => s.lanes).flatMap((s) => remoteGroups({ ...s.machine }, s.lanes)),
|
|
106
|
+
machines: () => listMachines().map((m) => {
|
|
107
|
+
const s = state.get(m.name);
|
|
108
|
+
return { name: m.name, host: m.host, ok: !!s?.lanes, error: s?.error || (s ? null : "asking…"), count: s?.lanes?.length ?? 0, at: s?.at ?? null };
|
|
109
|
+
}),
|
|
110
|
+
get: (name) => state.get(name),
|
|
111
|
+
refresh: poll,
|
|
112
|
+
};
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
function snapshot(remote) {
|
|
116
|
+
const local = readLanes().map((g) => ({ ...g, machine: null }));
|
|
117
|
+
const groups = [...local, ...remote.groups()];
|
|
118
|
+
for (const g of groups) for (const l of g.lanes) l.caps = laneCaps(l);
|
|
119
|
+
return { headline: headline(groups), groups, machines: remote.machines(), holds: listHolds(), at: Date.now() };
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
function laneByKey(remote, fullKey) {
|
|
123
|
+
const { machine, key } = splitKey(fullKey);
|
|
124
|
+
if (!machine) { const lane = findLane(key); return lane ? { lane, machine: null } : null; }
|
|
125
|
+
const s = remote.get(machine);
|
|
126
|
+
const lane = s?.lanes?.find((l) => l.key === key);
|
|
127
|
+
return lane ? { lane, machine: s.machine } : null;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
// One verb, wherever the lane lives.
|
|
131
|
+
async function act(remote, verb, fullKey, opts = {}) {
|
|
132
|
+
const found = laneByKey(remote, fullKey);
|
|
133
|
+
if (!found) return { ok: false, error: "no such lane (it may have just ended)" };
|
|
134
|
+
const { lane, machine } = found;
|
|
135
|
+
if (machine) {
|
|
136
|
+
const r = await sh("ssh", sshArgs(machine, ["seldon", "lane", verb, lane.key, ...(opts.force ? ["--force"] : [])]), 30_000);
|
|
137
|
+
remote.refresh();
|
|
138
|
+
return r.ok ? { ok: true } : { ok: false, error: r.error };
|
|
139
|
+
}
|
|
140
|
+
const r = verb === "stop" ? stopLane(lane) : verb === "resume" ? resumeLane(lane) : removeLane(lane, { force: !!opts.force });
|
|
141
|
+
return r.why ? { ok: false, error: r.why } : r;
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
async function tmuxOn(machine, args) {
|
|
145
|
+
return machine ? sh("ssh", sshArgs(machine, ["tmux", ...args])) : sh("tmux", args);
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
async function peek(remote, fullKey, lines = 60) {
|
|
149
|
+
const found = laneByKey(remote, fullKey);
|
|
150
|
+
if (!found?.lane.tmuxSession) return { ok: false, error: "no screen to read for this lane" };
|
|
151
|
+
const r = await tmuxOn(found.machine, ["capture-pane", "-p", "-J", "-t", found.lane.tmuxSession, "-S", `-${Math.min(400, lines)}`]);
|
|
152
|
+
return r.ok ? { ok: true, screen: r.out.replace(/\s+$/, "") } : r;
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
async function reply(remote, fullKey, body) {
|
|
156
|
+
const found = laneByKey(remote, fullKey);
|
|
157
|
+
const steps = replyArgs(found?.lane.tmuxSession, body);
|
|
158
|
+
if (!steps) return { ok: false, error: "nothing to send, or no pane to send it to" };
|
|
159
|
+
for (const args of steps) { const r = await tmuxOn(found.machine, args); if (!r.ok) return r; }
|
|
160
|
+
return { ok: true };
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
async function start(remote, { root, machine, task, agent = "claude" }) {
|
|
164
|
+
if (!HARNESSES.includes(agent)) return { ok: false, error: `unknown agent ${agent}` };
|
|
165
|
+
if (machine) {
|
|
166
|
+
const m = remote.get(machine)?.machine;
|
|
167
|
+
if (!m) return { ok: false, error: `unknown machine ${machine}` };
|
|
168
|
+
const r = await sh("ssh", sshArgs(m, ["seldon", "lane", "start", root, "--task", task, "--agent", agent]), 30_000);
|
|
169
|
+
remote.refresh();
|
|
170
|
+
return r.ok ? { ok: true } : { ok: false, error: r.error };
|
|
171
|
+
}
|
|
172
|
+
const dir = projectRoot(root) || root;
|
|
173
|
+
return startLane({ root: dir, name: dir.split("/").pop(), task, harness: agent });
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
// The open plan, each item with the lane already on it (the panel's own matching rule).
|
|
177
|
+
async function plan(remote, { root, machine }) {
|
|
178
|
+
const withLanes = (items, lanes) => items && items.map((it) => ({ ...it, lane: laneForItem(it, lanes)?.name ?? null }));
|
|
179
|
+
if (!machine) return { ok: true, items: withLanes(readPlan(root), allLanes()) };
|
|
180
|
+
const s = remote.get(machine);
|
|
181
|
+
if (!s) return { ok: false, error: `unknown machine ${machine}` };
|
|
182
|
+
const r = await sh("ssh", sshArgs(s.machine, ["foundation", "queue", "--list", "--json", "--dir", root]));
|
|
183
|
+
const line = r.out.split("\n").reverse().find((l) => l.trim().startsWith("["));
|
|
184
|
+
try { return { ok: true, items: withLanes(line ? JSON.parse(line) : null, s.lanes || []) }; } catch { return { ok: true, items: null }; }
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
const readBody = (req) => new Promise((res) => {
|
|
188
|
+
let raw = ""; req.on("data", (c) => { raw += c; if (raw.length > 64_000) req.destroy(); });
|
|
189
|
+
req.on("end", () => { try { res(JSON.parse(raw || "{}")); } catch { res({}); } });
|
|
190
|
+
});
|
|
191
|
+
|
|
192
|
+
// The token, made once and kept owner-only (0600). Delete the file to change it.
|
|
193
|
+
export function serveToken(home = SELDON_HOME) {
|
|
194
|
+
const file = join(home, "serve-token");
|
|
195
|
+
try { const t = readFileSync(file, "utf8").trim(); if (t.length >= 32) return t; } catch { /* first run */ }
|
|
196
|
+
const t = randomBytes(24).toString("base64url");
|
|
197
|
+
mkdirSync(home, { recursive: true });
|
|
198
|
+
writeFileSync(file, t + "\n", { mode: 0o600 }); chmodSync(file, 0o600);
|
|
199
|
+
return t;
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
export function serve({ port = 7930, token, owner = null, tailnet = false, allowReply = false } = {}) {
|
|
203
|
+
if (!token) throw new Error("seldon serve needs a token");
|
|
204
|
+
if (tailnet && !owner) throw new Error("seldon serve --tailnet needs an owner");
|
|
205
|
+
const remote = remoteCache();
|
|
206
|
+
const page = () => readFileSync(join(HERE, "web", "index.html"), "utf8"); // re-read: edit + reload
|
|
207
|
+
const send = (res, code, body, type = "application/json") => {
|
|
208
|
+
res.writeHead(code, { "content-type": type, "cache-control": "no-store", "x-content-type-options": "nosniff",
|
|
209
|
+
"referrer-policy": "no-referrer", "x-frame-options": "DENY" });
|
|
210
|
+
res.end(type === "application/json" ? JSON.stringify(body) : body);
|
|
211
|
+
};
|
|
212
|
+
const server = createServer(async (req, res) => {
|
|
213
|
+
const url = new URL(req.url, "http://x");
|
|
214
|
+
const denied = guard({ path: url.pathname, host: req.headers.host, headers: req.headers }, { token, owner, tailnet });
|
|
215
|
+
if (denied) return send(res, 403, { ok: false, error: denied });
|
|
216
|
+
try {
|
|
217
|
+
if (req.method === "GET" && url.pathname === "/") return send(res, 200, page(), "text/html; charset=utf-8");
|
|
218
|
+
if (req.method === "GET" && url.pathname === "/manifest.webmanifest")
|
|
219
|
+
return send(res, 200, JSON.stringify({ name: "seldon", short_name: "seldon", display: "standalone", start_url: "/", background_color: "#0e0f0c", theme_color: "#0e0f0c" }), "application/manifest+json");
|
|
220
|
+
if (req.method === "GET" && url.pathname === "/api/state") return send(res, 200, { ...snapshot(remote), allowReply });
|
|
221
|
+
if (req.method === "GET" && url.pathname === "/api/peek") return send(res, 200, await peek(remote, url.searchParams.get("key")));
|
|
222
|
+
if (req.method === "GET" && url.pathname === "/api/plan")
|
|
223
|
+
return send(res, 200, await plan(remote, { root: url.searchParams.get("root"), machine: url.searchParams.get("machine") || null }));
|
|
224
|
+
if (req.method === "POST") {
|
|
225
|
+
const body = await readBody(req);
|
|
226
|
+
const m = url.pathname.match(/^\/api\/lane\/(stop|resume|rm)$/);
|
|
227
|
+
if (m) return send(res, 200, await act(remote, m[1], body.key, body));
|
|
228
|
+
if (url.pathname === "/api/lane/start") return send(res, 200, await start(remote, body));
|
|
229
|
+
if (url.pathname === "/api/lane/reply") {
|
|
230
|
+
if (!allowReply) return send(res, 403, { ok: false, error: "replies are off — start with: seldon serve --allow-reply" });
|
|
231
|
+
return send(res, 200, await reply(remote, body.lane, body));
|
|
232
|
+
}
|
|
233
|
+
if (url.pathname === "/api/plan/add" && !body.machine && body.root && body.text)
|
|
234
|
+
return send(res, 200, addToPlan(body.root, String(body.text).slice(0, 500), body.priority || "P2"));
|
|
235
|
+
}
|
|
236
|
+
send(res, 404, { ok: false, error: "not found" });
|
|
237
|
+
} catch (e) { send(res, 500, { ok: false, error: e.message }); }
|
|
238
|
+
});
|
|
239
|
+
server.listen(port, "127.0.0.1");
|
|
240
|
+
return server;
|
|
241
|
+
}
|
package/lib/telegram.mjs
ADDED
|
@@ -0,0 +1,89 @@
|
|
|
1
|
+
// `seldon tell` — any agent can message you on Telegram: `seldon tell "the build is green"`.
|
|
2
|
+
//
|
|
3
|
+
// The bot token is a secret and lives in comb (TELEGRAM_BOT_TOKEN): seldon never stores it,
|
|
4
|
+
// prints it or puts it on a command line — `comb run` hands it over in the environment. The
|
|
5
|
+
// chat id is not a secret (it is useless without the token), so `seldon tell --setup` finds it
|
|
6
|
+
// once and keeps it in ~/.seldon/telegram.json.
|
|
7
|
+
//
|
|
8
|
+
// Sending only. Many sessions can send through one bot at once; reading a bot's messages is
|
|
9
|
+
// one-reader-only — Claude Code's own Telegram channel, on the same bot, for one session.
|
|
10
|
+
// --setup reads once (getUpdates), so it runs before that channel starts.
|
|
11
|
+
import { readFileSync, writeFileSync, mkdirSync, statSync } from "node:fs";
|
|
12
|
+
import { join, basename } from "node:path";
|
|
13
|
+
import { SELDON_HOME } from "./agents.mjs";
|
|
14
|
+
|
|
15
|
+
export const TOKEN_NAME = "TELEGRAM_BOT_TOKEN";
|
|
16
|
+
// The comb name the token is stored under: TELEGRAM_BOT_TOKEN unless setup was told another.
|
|
17
|
+
export const tokenName = (chat = readChat()) => chat?.tokenName || TOKEN_NAME;
|
|
18
|
+
export const MAX = 4096; // Telegram's limit per message
|
|
19
|
+
export const MAX_UPLOAD = 50 * 1024 * 1024; // a bot may upload up to 50 MB
|
|
20
|
+
const CONFIG = () => join(SELDON_HOME, "telegram.json");
|
|
21
|
+
|
|
22
|
+
// ---- pure -------------------------------------------------------------------------
|
|
23
|
+
// Long text goes out in pieces, split at a line break when there is one near the limit.
|
|
24
|
+
export function chunks(text, max = MAX) {
|
|
25
|
+
const out = [];
|
|
26
|
+
let s = String(text);
|
|
27
|
+
while (s.length > max) {
|
|
28
|
+
const cut = s.lastIndexOf("\n", max);
|
|
29
|
+
const at = cut > max * 0.5 ? cut : max;
|
|
30
|
+
out.push(s.slice(0, at));
|
|
31
|
+
s = s.slice(at).replace(/^\n/, "");
|
|
32
|
+
}
|
|
33
|
+
if (s.length) out.push(s);
|
|
34
|
+
return out;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
// The private chat that last wrote to the bot: whoever just sent it /start during --setup.
|
|
38
|
+
export function chatFromUpdates(updates) {
|
|
39
|
+
const msgs = (updates?.result || []).map((u) => u.message || u.edited_message).filter((m) => m?.chat?.type === "private");
|
|
40
|
+
const m = msgs.at(-1);
|
|
41
|
+
return m ? { id: m.chat.id, name: m.chat.username || m.chat.first_name || null } : null;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
// ---- I/O --------------------------------------------------------------------------
|
|
45
|
+
export function readChat() {
|
|
46
|
+
try { return JSON.parse(readFileSync(CONFIG(), "utf8")); } catch { return null; }
|
|
47
|
+
}
|
|
48
|
+
export function writeChat(chat) {
|
|
49
|
+
mkdirSync(SELDON_HOME, { recursive: true });
|
|
50
|
+
writeFileSync(CONFIG(), JSON.stringify(chat) + "\n", { mode: 0o600 });
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
// Errors name the method and Telegram's description, never the URL (it carries the token).
|
|
54
|
+
async function call(token, method, body) {
|
|
55
|
+
const r = await fetch(`https://api.telegram.org/bot${token}/${method}`, body instanceof FormData
|
|
56
|
+
? { method: "POST", body } : { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body || {}) });
|
|
57
|
+
const j = await r.json().catch(() => ({}));
|
|
58
|
+
if (!j.ok) throw new Error(`telegram ${method}: ${j.description || r.status}`);
|
|
59
|
+
return j;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
export const getUpdates = (token) => call(token, "getUpdates", { allowed_updates: ["message"] });
|
|
63
|
+
|
|
64
|
+
export async function sendText(token, chatId, text) {
|
|
65
|
+
for (const part of chunks(text)) await call(token, "sendMessage", { chat_id: chatId, text: part, disable_web_page_preview: true });
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
// How a file shows up in the chat: images inline, videos playable, GIFs animated, audio as a
|
|
69
|
+
// track, anything else as a document.
|
|
70
|
+
export function mediaKind(path) {
|
|
71
|
+
const ext = String(path).toLowerCase().split(".").pop();
|
|
72
|
+
if (["png", "jpg", "jpeg", "webp"].includes(ext)) return { method: "sendPhoto", field: "photo" };
|
|
73
|
+
if (["mp4", "mov", "m4v", "webm"].includes(ext)) return { method: "sendVideo", field: "video" };
|
|
74
|
+
if (ext === "gif") return { method: "sendAnimation", field: "animation" };
|
|
75
|
+
if (["mp3", "m4a", "ogg", "wav", "flac"].includes(ext)) return { method: "sendAudio", field: "audio" };
|
|
76
|
+
return { method: "sendDocument", field: "document" };
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
export async function sendFile(token, chatId, path, caption = "") {
|
|
80
|
+
const size = statSync(path).size;
|
|
81
|
+
if (size > MAX_UPLOAD) throw new Error(`${basename(path)} is ${(size / 1048576).toFixed(0)} MB — Telegram bots can send up to 50 MB`);
|
|
82
|
+
const { method, field } = mediaKind(path);
|
|
83
|
+
const form = new FormData();
|
|
84
|
+
form.set("chat_id", String(chatId));
|
|
85
|
+
if (caption) form.set("caption", caption.slice(0, 1024));
|
|
86
|
+
if (method === "sendVideo") form.set("supports_streaming", "true");
|
|
87
|
+
form.set(field, new Blob([readFileSync(path)]), basename(path));
|
|
88
|
+
await call(token, method, form);
|
|
89
|
+
}
|
|
@@ -0,0 +1,351 @@
|
|
|
1
|
+
<!doctype html>
|
|
2
|
+
<html lang="en">
|
|
3
|
+
<head>
|
|
4
|
+
<meta charset="utf-8">
|
|
5
|
+
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
|
|
6
|
+
<meta name="theme-color" content="#0e0f0c">
|
|
7
|
+
<meta name="apple-mobile-web-app-capable" content="yes">
|
|
8
|
+
<link rel="manifest" href="/manifest.webmanifest">
|
|
9
|
+
<title>seldon</title>
|
|
10
|
+
<style>
|
|
11
|
+
:root {
|
|
12
|
+
--bg: #f4f2ec; --card: #fffdf8; --ink: #1b1c18; --mute: #6d6c64; --line: #e2dfd5;
|
|
13
|
+
--need: #c2410c; --need-bg: #fdecdf; --work: #2f7d4f; --idle: #8b8a80; --fail: #b42318; --accent: #1b1c18;
|
|
14
|
+
--mono: ui-monospace, "SF Mono", "JetBrains Mono", Menlo, monospace;
|
|
15
|
+
--sans: -apple-system, system-ui, "Segoe UI", Roboto, sans-serif;
|
|
16
|
+
--r: 14px; --safe-b: env(safe-area-inset-bottom, 0px);
|
|
17
|
+
}
|
|
18
|
+
@media (prefers-color-scheme: dark) { :root:not([data-theme="light"]) {
|
|
19
|
+
--bg: #0e0f0c; --card: #171814; --ink: #ecebe4; --mute: #8f8e85; --line: #2a2b25;
|
|
20
|
+
--need: #fb923c; --need-bg: #2a1a0e; --work: #5fbf86; --idle: #77766d; --fail: #f87171; --accent: #ecebe4;
|
|
21
|
+
} }
|
|
22
|
+
:root[data-theme="dark"] {
|
|
23
|
+
--bg: #0e0f0c; --card: #171814; --ink: #ecebe4; --mute: #8f8e85; --line: #2a2b25;
|
|
24
|
+
--need: #fb923c; --need-bg: #2a1a0e; --work: #5fbf86; --idle: #77766d; --fail: #f87171; --accent: #ecebe4;
|
|
25
|
+
}
|
|
26
|
+
* { box-sizing: border-box; }
|
|
27
|
+
html, body { margin: 0; background: var(--bg); color: var(--ink); font: 15px/1.4 var(--sans); -webkit-text-size-adjust: 100%; }
|
|
28
|
+
button, input, textarea, select { font: inherit; color: inherit; }
|
|
29
|
+
button { cursor: pointer; }
|
|
30
|
+
.wrap { max-width: 640px; margin: 0 auto; padding: 0 16px calc(96px + var(--safe-b)); }
|
|
31
|
+
|
|
32
|
+
/* top */
|
|
33
|
+
header { position: sticky; top: 0; z-index: 5; background: color-mix(in srgb, var(--bg) 92%, transparent); backdrop-filter: blur(10px);
|
|
34
|
+
padding: calc(10px + env(safe-area-inset-top, 0px)) 0 10px; border-bottom: 1px solid var(--line); }
|
|
35
|
+
.top { display: flex; align-items: baseline; gap: 10px; }
|
|
36
|
+
.mark { font: 700 13px/1 var(--mono); letter-spacing: .28em; }
|
|
37
|
+
.head { flex: 1; min-width: 0; color: var(--mute); font-size: 13px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
|
|
38
|
+
.live { width: 8px; height: 8px; border-radius: 50%; background: var(--work); align-self: center; transition: opacity .3s; }
|
|
39
|
+
.live.stale { background: var(--fail); }
|
|
40
|
+
.chips { display: flex; gap: 8px; overflow-x: auto; margin-top: 10px; scrollbar-width: none; }
|
|
41
|
+
.chips::-webkit-scrollbar { display: none; }
|
|
42
|
+
.chip { flex: none; min-height: 44px; padding: 0 14px; border-radius: 999px; border: 1px solid var(--line); background: var(--card);
|
|
43
|
+
display: inline-flex; align-items: center; gap: 6px; font-size: 13px; }
|
|
44
|
+
.chip[aria-pressed="true"] { background: var(--accent); color: var(--bg); border-color: var(--accent); }
|
|
45
|
+
.chip .n { font: 600 12px var(--mono); }
|
|
46
|
+
.chip.need .n { color: var(--need); }
|
|
47
|
+
.chip[aria-pressed="true"].need .n { color: inherit; }
|
|
48
|
+
.chip .dot { width: 7px; height: 7px; }
|
|
49
|
+
|
|
50
|
+
.holds { margin: 12px 0 0; font: 12px var(--mono); color: var(--mute); }
|
|
51
|
+
.holds b { color: var(--ink); font-weight: 600; }
|
|
52
|
+
|
|
53
|
+
/* projects + lanes */
|
|
54
|
+
section.proj { margin-top: 18px; }
|
|
55
|
+
.ph { display: flex; align-items: center; gap: 8px; min-height: 44px; }
|
|
56
|
+
.ph h2 { margin: 0; font-size: 15px; font-weight: 650; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
|
57
|
+
.ph .at { font: 12px var(--mono); color: var(--mute); flex: none; }
|
|
58
|
+
.ph .sp { flex: 1; }
|
|
59
|
+
.ghost { min-height: 44px; min-width: 44px; padding: 0 12px; border: 0; background: none; color: var(--mute); font-size: 13px; border-radius: 10px; }
|
|
60
|
+
.ghost:active { background: var(--line); }
|
|
61
|
+
.card { background: var(--card); border: 1px solid var(--line); border-radius: var(--r); overflow: hidden; }
|
|
62
|
+
.lane { display: grid; grid-template-columns: 22px 1fr auto; gap: 2px 10px; align-items: center; width: 100%; text-align: left;
|
|
63
|
+
padding: 12px 14px; min-height: 60px; border: 0; background: none; border-top: 1px solid var(--line); }
|
|
64
|
+
.lane:first-child { border-top: 0; }
|
|
65
|
+
.lane:active { background: var(--line); }
|
|
66
|
+
.lane.needs-you { background: var(--need-bg); }
|
|
67
|
+
.lane .g { grid-row: span 2; display: grid; place-items: center; }
|
|
68
|
+
.lane .nm { min-width: 0; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
|
69
|
+
.lane .ag { font: 12px var(--mono); color: var(--mute); }
|
|
70
|
+
.lane .dt { grid-column: 2 / 4; min-width: 0; font-size: 13px; color: var(--mute); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
|
71
|
+
.lane.needs-you .dt { color: var(--need); font-weight: 600; }
|
|
72
|
+
.dot { width: 10px; height: 10px; border-radius: 50%; background: var(--idle); display: inline-block; flex: none; }
|
|
73
|
+
.dot.needs-you { background: var(--need); box-shadow: 0 0 0 4px color-mix(in srgb, var(--need) 25%, transparent); animation: pulse 1.6s infinite; }
|
|
74
|
+
.dot.working, .dot.running { background: var(--work); }
|
|
75
|
+
.dot.failed { background: var(--fail); }
|
|
76
|
+
.dot.stopped { background: transparent; border: 2px solid var(--idle); }
|
|
77
|
+
@keyframes pulse { 50% { box-shadow: 0 0 0 7px transparent; } }
|
|
78
|
+
@media (prefers-reduced-motion: reduce) { .dot.needs-you { animation: none; } }
|
|
79
|
+
.empty { padding: 40px 8px; text-align: center; color: var(--mute); }
|
|
80
|
+
.empty p { margin: 6px 0; }
|
|
81
|
+
|
|
82
|
+
/* fab */
|
|
83
|
+
.fab { position: fixed; right: max(16px, calc(50% - 304px)); bottom: calc(18px + var(--safe-b)); z-index: 6; min-height: 52px; padding: 0 20px;
|
|
84
|
+
border-radius: 999px; border: 0; background: var(--accent); color: var(--bg); font-weight: 650; box-shadow: 0 6px 24px rgb(0 0 0 / .25); }
|
|
85
|
+
|
|
86
|
+
/* sheet */
|
|
87
|
+
.scrim { position: fixed; inset: 0; background: rgb(0 0 0 / .45); z-index: 10; opacity: 0; pointer-events: none; transition: opacity .2s; }
|
|
88
|
+
.scrim.on { opacity: 1; pointer-events: auto; }
|
|
89
|
+
.sheet { position: fixed; left: 0; right: 0; bottom: 0; z-index: 11; max-width: 640px; margin: 0 auto; max-height: 92dvh; overflow-y: auto;
|
|
90
|
+
background: var(--card); border-radius: 18px 18px 0 0; padding: 8px 16px calc(20px + var(--safe-b)); transform: translateY(105%); transition: transform .22s ease-out; }
|
|
91
|
+
.sheet.on { transform: none; }
|
|
92
|
+
.grab { width: 40px; height: 5px; border-radius: 3px; background: var(--line); margin: 4px auto 12px; }
|
|
93
|
+
.sheet h3 { margin: 0; font-size: 18px; overflow-wrap: anywhere; }
|
|
94
|
+
.meta { display: flex; flex-wrap: wrap; gap: 6px 12px; margin: 6px 0 14px; font: 12px var(--mono); color: var(--mute); }
|
|
95
|
+
.meta .st { display: inline-flex; gap: 6px; align-items: center; color: var(--ink); }
|
|
96
|
+
.screen { background: #0b0c0a; color: #d8d6cc; font: 11.5px/1.45 var(--mono); border-radius: 10px; padding: 10px 12px; max-height: 42dvh;
|
|
97
|
+
overflow: auto; white-space: pre; margin: 0 0 12px; }
|
|
98
|
+
.note { font-size: 13px; color: var(--mute); background: var(--bg); border-radius: 10px; padding: 10px 12px; margin: 0 0 12px; }
|
|
99
|
+
.note code { font: 12px var(--mono); color: var(--ink); overflow-wrap: anywhere; }
|
|
100
|
+
.keys { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; margin-bottom: 8px; }
|
|
101
|
+
.k { min-height: 44px; border-radius: 10px; border: 1px solid var(--line); background: var(--bg); font: 600 14px var(--mono); }
|
|
102
|
+
.k:active { background: var(--line); }
|
|
103
|
+
.row { display: flex; gap: 8px; }
|
|
104
|
+
.row > * { min-width: 0; }
|
|
105
|
+
.in { flex: 1; min-height: 44px; border-radius: 10px; border: 1px solid var(--line); background: var(--bg); padding: 10px 12px; }
|
|
106
|
+
textarea.in { min-height: 96px; resize: vertical; width: 100%; }
|
|
107
|
+
select.in { width: 100%; }
|
|
108
|
+
.btn { min-height: 44px; padding: 0 16px; border-radius: 10px; border: 1px solid var(--line); background: var(--bg); font-weight: 600; }
|
|
109
|
+
.btn.primary { background: var(--accent); color: var(--bg); border-color: var(--accent); }
|
|
110
|
+
.btn.danger { color: var(--fail); }
|
|
111
|
+
.btn.danger.armed { background: var(--fail); color: #fff; border-color: var(--fail); }
|
|
112
|
+
.btn:disabled { opacity: .5; }
|
|
113
|
+
.actions { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 14px; }
|
|
114
|
+
.actions .btn { flex: 1 1 30%; }
|
|
115
|
+
label.f { display: block; font-size: 12px; color: var(--mute); margin: 12px 0 6px; font-weight: 600; letter-spacing: .02em; }
|
|
116
|
+
.seg { display: grid; grid-template-columns: repeat(3, 1fr); gap: 6px; }
|
|
117
|
+
.seg button { min-height: 44px; border-radius: 10px; border: 1px solid var(--line); background: var(--bg); font: 13px var(--mono); }
|
|
118
|
+
.seg button[aria-pressed="true"] { background: var(--accent); color: var(--bg); border-color: var(--accent); }
|
|
119
|
+
.plan { list-style: none; margin: 0; padding: 0; }
|
|
120
|
+
.plan li { display: flex; gap: 10px; align-items: center; padding: 10px 0; border-top: 1px solid var(--line); }
|
|
121
|
+
.plan li:first-child { border-top: 0; }
|
|
122
|
+
.plan .pr { font: 600 11px var(--mono); color: var(--mute); flex: none; width: 22px; }
|
|
123
|
+
.plan .tx { flex: 1; min-width: 0; font-size: 14px; }
|
|
124
|
+
.plan .on { font: 11px var(--mono); color: var(--work); }
|
|
125
|
+
.toast { position: fixed; left: 16px; right: 16px; bottom: calc(84px + var(--safe-b)); z-index: 20; max-width: 560px; margin: 0 auto;
|
|
126
|
+
background: var(--ink); color: var(--bg); padding: 12px 14px; border-radius: 12px; font-size: 14px; opacity: 0; transform: translateY(8px);
|
|
127
|
+
transition: .2s; pointer-events: none; }
|
|
128
|
+
.toast.on { opacity: 1; transform: none; }
|
|
129
|
+
.toast.err { background: var(--fail); color: #fff; }
|
|
130
|
+
</style>
|
|
131
|
+
</head>
|
|
132
|
+
<body>
|
|
133
|
+
<header><div class="wrap" style="padding-bottom:0">
|
|
134
|
+
<div class="top"><span class="mark">SELDON</span><span class="head" id="head">…</span><span class="live" id="live" title="live"></span></div>
|
|
135
|
+
<div class="chips" id="chips" role="toolbar" aria-label="filter"></div>
|
|
136
|
+
<div class="holds" id="holds"></div>
|
|
137
|
+
</div></header>
|
|
138
|
+
<main class="wrap" id="main"></main>
|
|
139
|
+
<button class="fab" data-act="new">+ lane</button>
|
|
140
|
+
<div class="scrim" id="scrim" data-act="close"></div>
|
|
141
|
+
<div class="sheet" id="sheet" role="dialog" aria-modal="true"><div class="grab"></div><div id="sheetBody"></div></div>
|
|
142
|
+
<div class="toast" id="toast" role="status"></div>
|
|
143
|
+
<script>
|
|
144
|
+
"use strict";
|
|
145
|
+
const $ = (id) => document.getElementById(id);
|
|
146
|
+
const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" }[c]));
|
|
147
|
+
const ago = (ms) => { if (!ms) return ""; const s = Math.max(0, (Date.now() - ms) / 1000 | 0);
|
|
148
|
+
return s < 60 ? s + "s" : s < 3600 ? (s / 60 | 0) + "m" : s < 86400 ? (s / 3600 | 0) + "h" : (s / 86400 | 0) + "d"; };
|
|
149
|
+
const detail = (l) => l.state === "needs-you" ? "needs you: " + (l.waitingFor || "input") : l.state === "running" ? "running (no state reported)" : l.state;
|
|
150
|
+
|
|
151
|
+
let S = null, filter = "all", sheet = null, peekTimer = null, lastNeed = -1;
|
|
152
|
+
// The token arrives once in the link seldon serve prints (#t=…), is kept on this device, and
|
|
153
|
+
// is taken out of the address bar so it never ends up in a screenshot or a shared URL.
|
|
154
|
+
const TOKEN = (() => {
|
|
155
|
+
const m = location.hash.match(/[#&]t=([A-Za-z0-9_-]+)/);
|
|
156
|
+
try { if (m) localStorage.setItem("seldon-token", m[1]); } catch {}
|
|
157
|
+
if (m) history.replaceState(null, "", location.pathname);
|
|
158
|
+
try { return m?.[1] || localStorage.getItem("seldon-token") || ""; } catch { return m?.[1] || ""; }
|
|
159
|
+
})();
|
|
160
|
+
const api = async (path, body) => {
|
|
161
|
+
const headers = { "x-seldon-token": TOKEN, ...(body ? { "content-type": "application/json" } : {}) };
|
|
162
|
+
const r = await fetch(path, body ? { method: "POST", headers, body: JSON.stringify(body) } : { headers });
|
|
163
|
+
const j = await r.json().catch(() => ({ ok: false, error: "bad reply (" + r.status + ")" }));
|
|
164
|
+
if (r.status === 403) locked(j.error);
|
|
165
|
+
return j;
|
|
166
|
+
};
|
|
167
|
+
function locked(why) {
|
|
168
|
+
$("head").textContent = "locked";
|
|
169
|
+
$("main").innerHTML = `<div class="empty"><p><b>This device isn't let in.</b></p><p>${esc(why)}</p>
|
|
170
|
+
<p>Open the link <code>seldon serve</code> printed in your terminal (it carries the token).</p></div>`;
|
|
171
|
+
throw new Error(why);
|
|
172
|
+
}
|
|
173
|
+
const toast = (msg, err) => { const t = $("toast"); t.textContent = msg; t.className = "toast on" + (err ? " err" : ""); clearTimeout(toast.t); toast.t = setTimeout(() => t.className = "toast", 2600); };
|
|
174
|
+
const allLanes = () => S ? S.groups.flatMap((g) => g.lanes.map((l) => ({ ...l, group: g }))) : [];
|
|
175
|
+
const laneBy = (key) => allLanes().find((l) => l.key === key);
|
|
176
|
+
|
|
177
|
+
// ---- poll -------------------------------------------------------------------------
|
|
178
|
+
async function refresh() {
|
|
179
|
+
try {
|
|
180
|
+
S = await api("/api/state");
|
|
181
|
+
$("live").classList.remove("stale");
|
|
182
|
+
render();
|
|
183
|
+
const need = allLanes().filter((l) => l.state === "needs-you").length;
|
|
184
|
+
if (lastNeed >= 0 && need > lastNeed) alertNeed(need);
|
|
185
|
+
lastNeed = need;
|
|
186
|
+
document.title = need ? `(${need}) seldon` : "seldon";
|
|
187
|
+
if (sheet?.type === "lane") renderLaneSheet(false);
|
|
188
|
+
} catch { $("live").classList.add("stale"); }
|
|
189
|
+
}
|
|
190
|
+
function alertNeed(n) {
|
|
191
|
+
navigator.vibrate?.(120);
|
|
192
|
+
if (document.hidden && "Notification" in window && Notification.permission === "granted")
|
|
193
|
+
new Notification("seldon", { body: n === 1 ? "an agent needs you" : n + " agents need you", tag: "seldon-need" });
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
// ---- render -----------------------------------------------------------------------
|
|
197
|
+
function render() {
|
|
198
|
+
$("head").textContent = S.headline;
|
|
199
|
+
const lanes = allLanes(), need = lanes.filter((l) => l.state === "needs-you").length;
|
|
200
|
+
const chips = [["all", "All", lanes.length, ""], ["need", "Needs you", need, "need"], ["here", "this mac", S.groups.filter((g) => !g.machine).reduce((a, g) => a + g.lanes.length, 0), ""],
|
|
201
|
+
...S.machines.map((m) => ["m:" + m.name, m.name, m.ok ? m.count : "—", m.ok ? "" : "off"])];
|
|
202
|
+
$("chips").innerHTML = chips.map(([id, label, n, cls]) =>
|
|
203
|
+
`<button class="chip ${cls}" data-act="filter" data-id="${esc(id)}" aria-pressed="${filter === id}">${cls === "off" ? '<span class="dot failed"></span>' : ""}${esc(label)} <span class="n">${esc(n)}</span></button>`).join("");
|
|
204
|
+
$("holds").innerHTML = S.holds?.length ? "held: " + S.holds.map((h) => `<b>${esc(h.name)}</b> → ${esc(h.who)}`).join(" · ") : "";
|
|
205
|
+
|
|
206
|
+
const groups = S.groups.map((g) => ({ ...g, lanes: g.lanes.filter((l) =>
|
|
207
|
+
filter === "need" ? l.state === "needs-you" : filter === "here" ? !g.machine : filter.startsWith("m:") ? g.machine === filter.slice(2) : true) }))
|
|
208
|
+
.filter((g) => g.lanes.length);
|
|
209
|
+
$("main").innerHTML = groups.length ? groups.map((g) => `
|
|
210
|
+
<section class="proj">
|
|
211
|
+
<div class="ph"><h2>${esc(g.lanes[0].projectName || g.name.replace(/ @.*/, ""))}</h2>${g.machine ? `<span class="at">@${esc(g.machine)}</span>` : ""}<span class="sp"></span>
|
|
212
|
+
<button class="ghost" data-act="plan" data-root="${esc(g.remoteRoot || g.root)}" data-machine="${esc(g.machine || "")}">plan</button>
|
|
213
|
+
<button class="ghost" data-act="new" data-root="${esc(g.remoteRoot || g.root)}" data-machine="${esc(g.machine || "")}" aria-label="new lane here">+</button></div>
|
|
214
|
+
<div class="card">${g.lanes.map((l) => `
|
|
215
|
+
<button class="lane ${esc(l.state)}" data-act="lane" data-key="${esc(l.key)}">
|
|
216
|
+
<span class="g"><span class="dot ${esc(l.state)}"></span></span>
|
|
217
|
+
<span class="nm">${esc(l.name || l.id || "?")}</span><span class="ag">${esc(l.harness)} ${esc(ago(l.startedAt))}</span>
|
|
218
|
+
<span class="dt">${esc(detail(l))}</span>
|
|
219
|
+
</button>`).join("")}</div>
|
|
220
|
+
</section>`).join("")
|
|
221
|
+
: `<div class="empty"><p><b>${filter === "need" ? "Nobody needs you." : "No agents here."}</b></p><p>${filter === "need" ? "You'll get a buzz when one does." : "Start one with + lane."}</p></div>`;
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
// ---- sheets -----------------------------------------------------------------------
|
|
225
|
+
function open(type, data) { sheet = { type, ...data }; $("scrim").classList.add("on"); $("sheet").classList.add("on"); }
|
|
226
|
+
function close() { sheet = null; clearInterval(peekTimer); $("scrim").classList.remove("on"); $("sheet").classList.remove("on"); }
|
|
227
|
+
|
|
228
|
+
function renderLaneSheet(full = true) {
|
|
229
|
+
const l = laneBy(sheet.key);
|
|
230
|
+
if (!l) { $("sheetBody").innerHTML = `<h3>Lane ended</h3><p class="note">It is no longer listed.</p>`; return; }
|
|
231
|
+
const c = l.caps || {};
|
|
232
|
+
const head = `<h3>${esc(l.name || l.id)}</h3>
|
|
233
|
+
<div class="meta"><span class="st"><span class="dot ${esc(l.state)}"></span>${esc(detail(l))}</span><span>${esc(l.harness)}</span>
|
|
234
|
+
<span>${esc(l.group.lanes[0].projectName || l.group.name)}${l.group.machine ? " @" + esc(l.group.machine) : ""}</span><span>${esc(ago(l.startedAt))}</span></div>`;
|
|
235
|
+
if (!full) { $("sheetBody").querySelector(".lanehead").innerHTML = head; return; }
|
|
236
|
+
$("sheetBody").innerHTML = `<div class="lanehead">${head}</div>
|
|
237
|
+
${c.peek ? `<pre class="screen" id="screen">reading the screen…</pre>` : ""}
|
|
238
|
+
${c.hint ? `<p class="note">No terminal pane to read for this lane. Open it with <code>${esc(c.hint)}</code>, or from the Claude app via Remote Control.</p>` : ""}
|
|
239
|
+
${c.reply && S.allowReply ? `
|
|
240
|
+
<div class="keys">${["1", "2", "3", "y"].map((k) => `<button class="k" data-act="text" data-v="${k}">${k}</button>`).join("")}
|
|
241
|
+
${[["enter", "⏎"], ["esc", "esc"], ["up", "↑"], ["down", "↓"]].map(([k, v]) => `<button class="k" data-act="key" data-v="${k}">${v}</button>`).join("")}</div>
|
|
242
|
+
<form class="row" data-form="reply"><input class="in" name="t" placeholder="reply to the agent…" autocomplete="off" enterkeyhint="send"><button class="btn primary">Send</button></form>`
|
|
243
|
+
: c.reply ? `<p class="note">Read-only. To answer from here, start it with <code>seldon serve --allow-reply</code>.</p>` : ""}
|
|
244
|
+
<div class="actions">
|
|
245
|
+
${c.stop ? `<button class="btn danger" data-act="stop">Stop</button>` : ""}
|
|
246
|
+
${c.resume ? `<button class="btn primary" data-act="resume">Resume</button>` : ""}
|
|
247
|
+
${c.rm ? `<button class="btn danger" data-act="rm">Remove</button>` : ""}
|
|
248
|
+
<button class="btn" data-act="close">Close</button>
|
|
249
|
+
</div>`;
|
|
250
|
+
clearInterval(peekTimer);
|
|
251
|
+
if (c.peek) { peek(); peekTimer = setInterval(peek, 2000); }
|
|
252
|
+
}
|
|
253
|
+
async function peek() {
|
|
254
|
+
const el = $("screen"); if (!el || !sheet) return;
|
|
255
|
+
const r = await api("/api/peek?key=" + encodeURIComponent(sheet.key));
|
|
256
|
+
const atBottom = el.scrollTop + el.clientHeight >= el.scrollHeight - 8;
|
|
257
|
+
el.textContent = r.ok ? (r.screen || "(empty)") : r.error;
|
|
258
|
+
if (atBottom) el.scrollTop = el.scrollHeight;
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
function projects() {
|
|
262
|
+
return S.groups.map((g) => ({ root: g.remoteRoot || g.root, machine: g.machine || "", label: (g.lanes[0]?.projectName || g.name.replace(/ @.*/, "")) + (g.machine ? " @" + g.machine : "") }));
|
|
263
|
+
}
|
|
264
|
+
function renderNew(d) {
|
|
265
|
+
const ps = projects(); const pick = ps.find((p) => p.root === d.root && p.machine === (d.machine || "")) || ps[0];
|
|
266
|
+
sheet.agent = sheet.agent || "claude";
|
|
267
|
+
$("sheetBody").innerHTML = `<h3>New lane</h3>
|
|
268
|
+
<form data-form="start">
|
|
269
|
+
<label class="f">Project</label>
|
|
270
|
+
<select class="in" name="p">${ps.map((p, i) => `<option value="${i}" ${p === pick ? "selected" : ""}>${esc(p.label)}</option>`).join("")}</select>
|
|
271
|
+
<label class="f">Task</label>
|
|
272
|
+
<textarea class="in" name="task" placeholder="fix the save crash">${esc(d.task || "")}</textarea>
|
|
273
|
+
<label class="f">Agent</label>
|
|
274
|
+
<div class="seg">${["claude", "codex", "opencode"].map((a) => `<button type="button" data-act="agent" data-v="${a}" aria-pressed="${sheet.agent === a}">${a}</button>`).join("")}</div>
|
|
275
|
+
<div class="actions"><button class="btn primary">Start lane</button><button type="button" class="btn" data-act="close">Cancel</button></div>
|
|
276
|
+
</form>`;
|
|
277
|
+
sheet.projects = ps;
|
|
278
|
+
}
|
|
279
|
+
async function renderPlan() {
|
|
280
|
+
$("sheetBody").innerHTML = `<h3>Plan</h3><p class="note">reading docs/QUEUE.md…</p>`;
|
|
281
|
+
const r = await api(`/api/plan?root=${encodeURIComponent(sheet.root)}&machine=${encodeURIComponent(sheet.machine || "")}`);
|
|
282
|
+
if (sheet?.type !== "plan") return;
|
|
283
|
+
const items = r.items;
|
|
284
|
+
$("sheetBody").innerHTML = `<h3>Plan</h3><div class="meta"><span>${esc(sheet.root)}${sheet.machine ? " @" + esc(sheet.machine) : ""}</span></div>
|
|
285
|
+
${!r.ok ? `<p class="note">${esc(r.error)}</p>` : items == null ? `<p class="note">No plan here (foundation not installed, or no docs/QUEUE.md).</p>`
|
|
286
|
+
: !items.length ? `<p class="note">The plan is empty.</p>`
|
|
287
|
+
: `<ul class="plan">${items.map((it, i) => `<li><span class="pr">${esc(it.priority || "")}</span><span class="tx">${esc(it.text)}</span>
|
|
288
|
+
${it.lane ? `<span class="on">● ${esc(it.lane)}</span>` : `<button class="btn" data-act="item" data-i="${i}">Start</button>`}</li>`).join("")}</ul>`}
|
|
289
|
+
${!sheet.machine && items ? `<form class="row" data-form="add" style="margin-top:12px"><input class="in" name="t" placeholder="add to the plan…" autocomplete="off"><button class="btn">Add</button></form>` : ""}
|
|
290
|
+
<div class="actions"><button class="btn" data-act="close">Close</button></div>`;
|
|
291
|
+
sheet.items = items;
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
// ---- one listener for everything ----------------------------------------------------
|
|
295
|
+
async function doLane(verb, btn) {
|
|
296
|
+
if (verb !== "resume" && !btn.classList.contains("armed")) { btn.classList.add("armed"); btn.textContent = "Tap again to " + verb.replace("rm", "remove"); setTimeout(() => { btn.classList.remove("armed"); btn.textContent = verb === "rm" ? "Remove" : "Stop"; }, 3000); return; }
|
|
297
|
+
btn.disabled = true;
|
|
298
|
+
const r = await api("/api/lane/" + verb, { key: sheet.key });
|
|
299
|
+
toast(r.ok ? ({ stop: "Stopped", resume: "Resumed", rm: "Removed" }[verb]) : r.error, !r.ok);
|
|
300
|
+
if (r.ok && verb !== "resume") close();
|
|
301
|
+
refresh();
|
|
302
|
+
}
|
|
303
|
+
document.addEventListener("click", async (e) => {
|
|
304
|
+
const b = e.target.closest("[data-act]"); if (!b) return;
|
|
305
|
+
const a = b.dataset.act;
|
|
306
|
+
if (a === "filter") { filter = b.dataset.id; render(); }
|
|
307
|
+
else if (a === "lane") { open("lane", { key: b.dataset.key }); renderLaneSheet(); maybeAskNotify(); }
|
|
308
|
+
else if (a === "new") { open("new", {}); renderNew({ root: b.dataset.root, machine: b.dataset.machine }); }
|
|
309
|
+
else if (a === "plan") { open("plan", { root: b.dataset.root, machine: b.dataset.machine }); renderPlan(); }
|
|
310
|
+
else if (a === "close") close();
|
|
311
|
+
else if (a === "agent") { sheet.agent = b.dataset.v; b.parentElement.querySelectorAll("button").forEach((x) => x.setAttribute("aria-pressed", x === b)); }
|
|
312
|
+
else if (["stop", "resume", "rm"].includes(a)) doLane(a, b);
|
|
313
|
+
else if (a === "key") reply({ key: b.dataset.v });
|
|
314
|
+
else if (a === "text") reply({ text: b.dataset.v, submit: false });
|
|
315
|
+
else if (a === "item") { const it = sheet.items[b.dataset.i]; const { root, machine } = sheet; open("new", {}); renderNew({ root, machine, task: it.text }); }
|
|
316
|
+
});
|
|
317
|
+
async function reply(what) {
|
|
318
|
+
const r = await api("/api/lane/reply", { lane: sheet.key, ...what });
|
|
319
|
+
if (!r.ok) toast(r.error, true); else { navigator.vibrate?.(15); setTimeout(peek, 250); }
|
|
320
|
+
}
|
|
321
|
+
document.addEventListener("submit", async (e) => {
|
|
322
|
+
const f = e.target.closest("[data-form]"); if (!f) return;
|
|
323
|
+
e.preventDefault();
|
|
324
|
+
const kind = f.dataset.form, btn = f.querySelector("button:not([type=button])");
|
|
325
|
+
if (kind === "reply") { const t = f.t.value; if (!t) return; f.t.value = ""; return reply({ text: t }); }
|
|
326
|
+
if (kind === "add") {
|
|
327
|
+
const t = f.t.value.trim(); if (!t) return;
|
|
328
|
+
const r = await api("/api/plan/add", { root: sheet.root, text: t });
|
|
329
|
+
toast(r.ok ? "Added to the plan" : r.error, !r.ok); if (r.ok) renderPlan(); return;
|
|
330
|
+
}
|
|
331
|
+
if (kind === "start") {
|
|
332
|
+
const p = sheet.projects[f.p.value], task = f.task.value.trim();
|
|
333
|
+
if (!p || !task) return toast("pick a project and write a task", true);
|
|
334
|
+
btn.disabled = true; btn.textContent = "Starting…";
|
|
335
|
+
const r = await api("/api/lane/start", { root: p.root, machine: p.machine || null, task, agent: sheet.agent });
|
|
336
|
+
toast(r.ok ? "Started " + (r.slug || "lane") : r.error, !r.ok);
|
|
337
|
+
if (r.ok) close(); else { btn.disabled = false; btn.textContent = "Start lane"; }
|
|
338
|
+
refresh();
|
|
339
|
+
}
|
|
340
|
+
});
|
|
341
|
+
// Notifications need a secure context (tailscale serve gives one) and a tap to ask.
|
|
342
|
+
function maybeAskNotify() {
|
|
343
|
+
if ("Notification" in window && Notification.permission === "default" && window.isSecureContext) Notification.requestPermission();
|
|
344
|
+
}
|
|
345
|
+
document.addEventListener("keydown", (e) => { if (e.key === "Escape" && sheet) close(); });
|
|
346
|
+
document.addEventListener("visibilitychange", () => { if (!document.hidden) refresh(); });
|
|
347
|
+
refresh();
|
|
348
|
+
setInterval(refresh, 3000);
|
|
349
|
+
</script>
|
|
350
|
+
</body>
|
|
351
|
+
</html>
|