@alphacoder-v0/pi-loops 0.24.0 → 0.24.2

package/docs/troubleshooting.md

@@ -43,8 +43,10 @@ longer loaded.
 
 **The browser window says "This browser has not been here before."** It has no cookie for this
 address, which is normal for a new device, a new browser, a private window, or after clearing site
-data. Press **add device** in a browser that is already signed in and scan the QR, or type the six
-digits into the box on that page. The terminal that started the session printed a code too.
+data. On this machine, run `pi-loops open` in a terminal (or `/pi-loops web` inside pi) for a link
+that signs this browser in. For another device, run `pi-loops pair`, or press **add device** in a
+browser that is already signed in and scan the QR, then type the six digits into the box on that
+page.
 
 **The phone cannot reach it at all.** The server binds loopback by default, and a phone has no
 route to that. Either `tailscale serve --bg 4173` (the server stays on loopback; the tailnet does

package/docs/web-ui-parity.md

@@ -327,7 +327,8 @@ weaker, and worth converting whenever one of them breaks.
       **Waiting on** and **If you don't** when the loop said them, then news. A card names its loop
       only when the list holds more than one loop's findings, and says where a claim runs only when
       that is not the conversation on screen (another conversation's or project's finding, or a
-      terminal that takes no messages). **See the run** is there only when the finding has a run.
+      terminal that takes no messages). **See the run** is there only when the finding has a run this page can read
+      (`test/page-server.test.ts`: *See the run is offered only for a transcript the server would read*).
       Every card carries its finding's whole id; no button names a position. `test/web-page.test.ts`:
       *the inbox shows decisions before news, each row only with a value, and where a claim runs
       only when that is not here*. `test/page-server.test.ts`: *GET /inbox: one project's cards, decisions first,
@@ -502,10 +503,10 @@ weaker, and worth converting whenever one of them breaks.
       open this on a phone. Wide, it is a column beside the conversation, which the rail's Loops
       button gives back to the conversation, remembered; up to 1100 px it is a drawer from that
       button; on a phone (760 px and less) it is the Loops tab.
-- [x] Thirteen controls do not fit across a narrow conversation. Below 1000 px of conversation,
+- [x] Twelve controls do not fit across a narrow conversation. Below 1000 px of conversation,
       whatever is beside it, the ones you reach for mid-conversation (undo, find, compact and resume)
       stay in the header on one row with ⋯, and the header stays two rows at a 1280 or 1440 px
-      window; reload, save, share, clear, add device, theme and notifications go behind ⋯. The
+      window; reload, save, share, add device, theme and notifications go behind ⋯. The
       sheet lists all of them, moved — not copied — into it. On a phone (760 px and less) every one is behind ⋯.
       `test/web-page.test.ts`: *the header's secondary actions move into a sheet and back*, *below
       1000 px of conversation, undo, find, compact and resume stay in the header and the rest go
@@ -591,8 +592,8 @@ weaker, and worth converting whenever one of them breaks.
       first; it replaces `new_trigger`'s confirm, so there is one question, never two. A scheduled
       turn, a sub-agent and pi-loops in the background ask nobody. `test/scoping.test.ts`: *the answer
       is promote_to_chat and fire_once for a rule, and stateful and verify for a schedule*, *a
-      sub-agent, a scheduled turn and a pi with no dialog keep today's gate: new_trigger asks the
-      host's confirm once and cron_create creates*; J8 in `test/journey/journeys/j08-watch.mjs`
+      sub-agent has no new_trigger; a scheduled turn and a pi with no dialog keep today's gate:
+      new_trigger asks the host's confirm once and cron_create creates*; J8 in `test/journey/journeys/j08-watch.mjs`
       drives the selector in tmux.
 - [x] At 390 px the box and the card fit: nothing scrolls sideways, the chips and buttons wrap, and
       every button is at least 32 px tall (J8 in `test/journey/journeys/j08-watch.mjs`).
@@ -742,7 +743,7 @@ weaker, and worth converting whenever one of them breaks.
       whether pi-loops runs*.
 - [x] **Starting over does not mean going back to a terminal.** The context is finished with far
       more often than the window is: a new session and going back to an earlier one are both here,
-      by button (the list's + New is the header's clear) and by `/clear`, `/new` and `/resume` typed
+      by button (the list's + New in this project) and by `/clear`, `/new` and `/resume` typed
       in the composer — the habit comes from a
       terminal and the muscle memory arrives with it. Neither deletes anything: the session being
       left is a file that `resume` lists, labelled by what was said in it rather than by a filename.
@@ -969,6 +970,17 @@ weaker, and worth converting whenever one of them breaks.
       otherwise reloading a bookmark with a stale code on it burns the budget the phone needs.
       `test/web.test.ts`: *a signed-in browser reloading a stale pairing code does not spend a
       guess*.
+- [x] The first browser on this machine gets in with one action. `pi-loops` prints one link with a
+      one-use key and opens the browser on it, or says it could not, so a paste of that link works
+      on the first try; on WSL the Windows browser is opened through `rundll32.exe`, then
+      `cmd.exe`, and "opened" is said only once a browser has spent the key. `pi-loops open` prints a fresh link, and the door names it.
+      `test/browser-open.test.ts`: *opened means the opener exited with a success code or is still
+      running*. `test/cli.test.ts`: *what pi-loops prints once the page has the conversation*,
+      *pi-loops open is a word of its own*. `test/web-page.test.ts`: *the door is a heading, one
+      line per way in, and the code field*.
+- [x] `/pi-loops web` opens the conversation you are in from inside pi, with no `pi-loops` on your
+      PATH: the same link and opener, and the link copied to the clipboard. Checked by reading
+      (`src/pi-loops.ts` cannot be imported by a test).
 - [x] Pairing survives an upgrade: the token and the paired devices are files outside the package,
       so a device stays signed in across restarts and new versions. A browser paired before 0.24.0
       pairs once more, because its cookie held the token, which no cookie may hold now.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphacoder-v0/pi-loops",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "An automation layer for pi: cron + stateful loops with a triage inbox, maker/checker verification, dynamic triggers, MCP notifications and tools, lifecycle hooks, session archives. A non-invasive pi extension.",
   "type": "module",
   "license": "MIT",

package/skills/pi-loops/SKILL.md

@@ -46,6 +46,8 @@ reported in your notes; report only new or newly closed issues". Findings should
 (a reason is shown to the loop's next run, so a finding the user calls noise can say why).
 `/cron` lists jobs, `/cron runs`, `/cron trace <job> [k]` shows what a run did. `/triggers rules`,
 `/triggers audit` for dynamic triggers.
+From a shell: `pi-loops inbox list --json`, `pi-loops inbox claim <id> --json`,
+`pi-loops inbox dismiss <id> --reason <text> --json`.
 
 ## Confirmations
 

package/src/activity.ts

@@ -8,7 +8,7 @@ import type { InboxEntry } from "./inbox.ts";
 import { ruleResultText, splitFinding } from "./inbox-card.ts";
 import { failingJobs } from "./job-health.ts";
 import { redact } from "./redact.ts";
-import { runCardFor } from "./run-card.ts";
+import { runCardFor, runCardsHere } from "./run-card.ts";
 import type { LoopJob, RunRecord } from "./store.ts";
 import type { AuditRecord } from "./triggers.ts";
 
@@ -45,7 +45,7 @@ export interface ActivityItem {
 	carded: boolean;
 	/** A rule check: its findings, so a row can point at the card. */
 	inboxIds: string[];
-	/** A rule check: the result also went to a conversation (`promote_to_chat`). */
+	/** A rule check: the result also went to a conversation (`promote_to_chat`). A run: its card is in this conversation. */
 	inChat: boolean;
 	/** The run's loop or the rule was made in the conversation asking. */
 	fromThisConversation: boolean;
@@ -123,7 +123,8 @@ export function activityFrom(input: ActivityInput): { items: ActivityItem[]; mor
 			...(!r.ok && r.error ? { error: clip(r.error) } : {}),
 			carded: runCardFor(r) === "card",
 			inboxIds: [],
-			inChat: false,
+			// Where its card is: a run someone asked for cards where they asked, not where its loop was made.
+			inChat: runCardFor(r) === "card" && runCardsHere([r], { sessionId: input.sessionId, inProject: here }).length > 0,
 			fromThisConversation: !!input.sessionId && r.forSession === input.sessionId,
 		});
 	}

package/src/browser-open.ts

@@ -0,0 +1,169 @@
+/**
+ * Which command opens a browser here, and whether one did. The table copies pi's own opener (macOS
+ * `open`, Windows `rundll32`) and adds the WSL branch pi lacks: there `xdg-open` finds no browser and
+ * exits 3 after five seconds, so the Windows side is asked directly, with pi's Windows opener. "Opened" comes from the exit
+ * code, never from the spawn alone: a terminal that says it opened a browser when nothing opened
+ * leaves a person waiting for a window that never comes.
+ */
+
+import { spawn } from "node:child_process";
+import * as os from "node:os";
+import { pathToFileURL } from "node:url";
+
+/**
+ * One command to try: what to run, from where, which exit codes mean the browser got it, and how
+ * long it may run before still running counts as opened.
+ */
+export type Opener = { cmd: string; args: string[]; cwd?: string; okExit: number[]; waitMs: number };
+
+/** For an opener that exits as soon as it has handed the address on. */
+const QUICK_MS = 1_500;
+/** xdg-open that finds no browser exits 3 after about five seconds. */
+const XDG_OPEN_MS = 10_000;
+
+/** What the choice depends on, passed in so a test can be any machine. */
+export type OpenEnv = { platform: NodeJS.Platform; release: string; env: NodeJS.ProcessEnv };
+
+/** ssh and mosh set at least one of these; opening a browser on the far end helps nobody. */
+export function isRemoteTty(env: NodeJS.ProcessEnv = process.env): boolean {
+	return ["SSH_CONNECTION", "SSH_CLIENT", "SSH_TTY", "MOSH_CONNECTION"].some((k) => !!env[k]);
+}
+
+function isWsl(e: Pick<OpenEnv, "platform" | "release" | "env">): boolean {
+	return e.platform === "linux" && (!!e.env.WSL_DISTRO_NAME || /microsoft/i.test(e.release));
+}
+
+/** The commands to try in order, or why none is tried. */
+export function openerFor(e: OpenEnv & { target: string }): Opener[] | "no-display" | "remote" {
+	if (isRemoteTty(e.env)) return "remote";
+	const t = e.target;
+	if (e.platform === "darwin") return [{ cmd: "open", args: [t], okExit: [0], waitMs: QUICK_MS }];
+	// No shell: cmd would read `&` in the address as the end of the command.
+	if (e.platform === "win32") return [{ cmd: "rundll32", args: ["url.dll,FileProtocolHandler", t], okExit: [0], waitMs: QUICK_MS }];
+	// Both start from a Windows drive: a long \\wsl.localhost cwd breaks them. Not wslview: wslu 3.2.3
+	// reads a wsl.localhost address as a relative Linux path and exits 0 without opening anything. Not
+	// explorer.exe: it exits 1 whether or not anything opened. rundll32 exits 0 even for a missing
+	// file, so cmd.exe is reached only when rundll32.exe cannot start.
+	if (isWsl(e))
+		return [
+			{ cmd: "rundll32.exe", args: ["url.dll,FileProtocolHandler", t], cwd: "/mnt/c", okExit: [0], waitMs: QUICK_MS },
+			// cmd re-reads its line: `^` escapes the characters it would act on.
+			{ cmd: "cmd.exe", args: ["/c", "start", "", t.replace(/[\^&|]/g, "^$&")], cwd: "/mnt/c", okExit: [0], waitMs: QUICK_MS },
+		];
+	if (!e.env.DISPLAY && !e.env.WAYLAND_DISPLAY) return "no-display";
+	return [{ cmd: "xdg-open", args: [t], okExit: [0], waitMs: XDG_OPEN_MS }];
+}
+
+/**
+ * The address the opener is given for the launch file, which holds the one-use key so no argv does.
+ * On WSL the browser is a Windows one, which reads the file through `\\wsl.localhost`: measured on
+ * WSL 2 with rundll32 and `cmd.exe /c start`, each loads the file and follows it to the page.
+ * Undefined on WSL without `WSL_DISTRO_NAME`, which that address needs, and for a path holding a
+ * character Windows does not allow in a name: `\\wsl.localhost` shows those under other names, so
+ * the browser cannot find the file while rundll32 still exits 0.
+ */
+export function openFileTarget(file: string, e: Pick<OpenEnv, "platform" | "release" | "env">): string | undefined {
+	const href = pathToFileURL(file).href;
+	if (!isWsl(e)) return href;
+	const distro = e.env.WSL_DISTRO_NAME;
+	return distro && !/[\\:*?"<>|]/.test(file) ? `file://wsl.localhost/${encodeURIComponent(distro)}${href.slice("file://".length)}` : undefined;
+}
+
+/** This machine, as `openerFor` reads it. */
+export function thisMachine(): OpenEnv {
+	return { platform: process.platform, release: os.release(), env: process.env };
+}
+
+/**
+ * Hand `target` to each opener in turn until one takes it: true when one exits with a code it
+ * counts as success, or is still running at its own deadline, which is how a browser started
+ * straight from the opener looks. `waitMs` replaces every deadline, for a test.
+ */
+export async function openUrl(target: string, e: OpenEnv = thisMachine(), waitMs?: number): Promise<boolean> {
+	const openers = openerFor({ ...e, target });
+	if (typeof openers === "string") return false;
+	for (const opener of openers) if (await tryOpener(opener, e.env, waitMs ?? opener.waitMs)) return true;
+	return false;
+}
+
+function tryOpener(o: Opener, env: NodeJS.ProcessEnv, waitMs: number): Promise<boolean> {
+	return new Promise((resolve) => {
+		let child: ReturnType<typeof spawn>;
+		try {
+			child = spawn(o.cmd, o.args, { stdio: "ignore", detached: true, cwd: o.cwd, env });
+		} catch {
+			resolve(false); // the next opener, or the printed link
+			return;
+		}
+		const timer = setTimeout(() => {
+			child.unref();
+			resolve(true);
+		}, waitMs);
+		child.once("error", () => {
+			clearTimeout(timer);
+			resolve(false);
+		});
+		child.once("exit", (code) => {
+			clearTimeout(timer);
+			resolve(code !== null && o.okExit.includes(code));
+		});
+	});
+}
+
+/** One command that copies its stdin to the clipboard and exits 0 when it has. */
+export type CopyCommand = { cmd: string; args: string[]; cwd?: string };
+
+/**
+ * The clipboard commands to try in order, the ones pi's `copyToClipboard` runs. Not OSC 52, which
+ * pi also writes and which no terminal confirms: tmux in Windows Terminal drops it, so a terminal
+ * that said "copied" after it could be wrong. None over ssh or mosh, where this machine's clipboard
+ * is not the one in front of you.
+ */
+export function copyCommandsFor(e: OpenEnv): CopyCommand[] {
+	if (isRemoteTty(e.env)) return [];
+	if (e.platform === "darwin") return [{ cmd: "pbcopy", args: [] }];
+	if (e.platform === "win32") return [{ cmd: "clip", args: [] }];
+	if (e.platform !== "linux") return [];
+	// The link is ASCII, so clip.exe reading it in the console code page changes nothing.
+	const windows = isWsl(e) ? [{ cmd: "clip.exe", args: [], cwd: "/mnt/c" }] : [];
+	return [
+		...windows,
+		...(e.env.WAYLAND_DISPLAY ? [{ cmd: "wl-copy", args: [] }] : []),
+		...(e.env.DISPLAY ? [{ cmd: "xclip", args: ["-selection", "clipboard"] }, { cmd: "xsel", args: ["--clipboard", "--input"] }] : []),
+	];
+}
+
+/** Copy `text` with the first command that takes it: true only when one exited 0. */
+export async function copyText(text: string, e: OpenEnv = thisMachine()): Promise<boolean> {
+	for (const c of copyCommandsFor(e)) if (await runCopy(c, text, e.env)) return true;
+	return false;
+}
+
+const COPY_WAIT_MS = 5_000;
+
+function runCopy(c: CopyCommand, text: string, env: NodeJS.ProcessEnv): Promise<boolean> {
+	return new Promise((resolve) => {
+		let child: ReturnType<typeof spawn>;
+		try {
+			// xclip and xsel stay behind to own the selection; "exit" is the command that answered.
+			child = spawn(c.cmd, c.args, { stdio: ["pipe", "ignore", "ignore"], cwd: c.cwd, env });
+		} catch {
+			resolve(false); // the next command
+			return;
+		}
+		const timer = setTimeout(() => {
+			child.kill();
+			resolve(false);
+		}, COPY_WAIT_MS);
+		child.once("error", () => {
+			clearTimeout(timer);
+			resolve(false);
+		});
+		child.once("exit", (code) => {
+			clearTimeout(timer);
+			resolve(code === 0);
+		});
+		child.stdin?.once("error", () => {}); // EPIPE from a command that exited first: its exit code decides
+		child.stdin?.end(text);
+	});
+}