@alphacoder-v0/pi-loops 0.22.8 → 0.24.0

package/src/trust.ts

@@ -9,8 +9,8 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ProjectTrustStore } from "@earendil-works/pi-coding-agent";
-import { withinProject } from "./presence.ts";
+import { ProjectTrustStore, hasTrustRequiringProjectResources } from "@earendil-works/pi-coding-agent";
+import { withinProject } from "./paths.ts";
 
 /** pi's own normalisation: resolved, then through symlinks where the path exists. */
 export function canonicalDir(dir: string): string {
@@ -22,6 +22,50 @@ export function canonicalDir(dir: string): string {
 	}
 }
 
+/**
+ * pi's own saved decision for `cwd`: the nearest entry, this directory's or a parent's, so a
+ * directory distrusted inside a trusted parent stays distrusted. A held turn uses it, because its
+ * directory is the one the person opened pi in; a loop's may be one a model chose, and uses
+ * `isExactlyTrusted`. "This session only" is never saved, so it never counts.
+ */
+export function isTrustedByPi(agentDir: string, cwd: string): boolean {
+	if (!cwd) return false;
+	return new ProjectTrustStore(agentDir).get(cwd) === true;
+}
+
+/**
+ * Whether `cwd` has anything that trust would change: what pi itself asks about (extensions,
+ * settings, skills), or pi-loops' own `.pi/mcp.toml` and `.pi/hooks.toml`. A directory with none of
+ * them loses nothing untrusted, and is not worth a warning.
+ */
+export function projectNeedsTrust(cwd: string): boolean {
+	if (!cwd) return false;
+	try {
+		if (hasTrustRequiringProjectResources(cwd)) return true;
+	} catch {
+		/* unreadable: fall through to our own files */
+	}
+	return fs.existsSync(path.join(cwd, ".pi", "mcp.toml")) || fs.existsSync(path.join(cwd, ".pi", "hooks.toml"));
+}
+
+/**
+ * Whether the window's project may load pi-loops' own project files (`.pi/mcp.toml`). pi answers
+ * `isProjectTrusted()` with yes in a directory that has nothing of pi's own to protect, without
+ * asking, so a cloned repository with only a `.pi/mcp.toml` would have its server command started
+ * on open. There a saved decision, or `pi --approve` on this command line, is required; where pi
+ * asked, its answer stands, and a no is no.
+ */
+export function windowTrusted(agentDir: string, cwd: string, piTrusted: boolean, approved = false): boolean {
+	if (!piTrusted || !cwd) return false;
+	let piAsked = false;
+	try {
+		piAsked = hasTrustRequiringProjectResources(cwd);
+	} catch {
+		/* unreadable: pi could not have asked either */
+	}
+	return piAsked || approved || isTrustedByPi(agentDir, cwd);
+}
+
 /** True only when the user trusted this very directory, not an ancestor of it. */
 export function isExactlyTrusted(agentDir: string, cwd: string): boolean {
 	if (!cwd) return false;

package/src/ui-prefs.ts

@@ -9,11 +9,10 @@
  * read-modify-write: the key is merged into whatever the file already holds, including keys this
  * module has never heard of.
  *
- * The file has a writer outside TypeScript. `src/web.mjs` is plain JS loaded without a TypeScript
- * loader, so it cannot import this module and keeps its own copy of the merge; the shape on disk is
- * therefore a contract, not an implementation detail. It is JSON with a two-space indent and a
- * trailing newline — the spelling the front end already wrote, kept because this is a file people
- * open and read — and unknown keys are left exactly as they were found.
+ * The browser page's server (src/page-server.ts) imports this module too, so every writer of the
+ * file goes through the one merge here. It is JSON with a two-space indent and a trailing newline,
+ * kept because this is a file people open and read, and unknown keys are left exactly as they were
+ * found.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -30,6 +29,14 @@ export interface UiPrefs {
 	 * made once and not in every window. `/pi-loops install-launcher` clears it when it writes one.
 	 */
 	launcher?: string;
+	/** `"stopped"` once a person stopped pi-loops by hand: no window starts it again until `pi-loops start`. */
+	host?: string;
+	/** `"shown"` once a session start has said that closed conversations' plain jobs now run in the host. */
+	heldJobsNotice?: string;
+	/** `"shown"` once a session start has named the plain jobs whose `--tools` now cap their turns. */
+	toolsCapNotice?: string;
+	/** The conversation the browser page last opened: what `GET /` opens. */
+	lastPage?: string;
 }
 
 const fileIn = (dir: string): string => path.join(dir, "ui.json");
@@ -58,6 +65,10 @@ export function readUiPrefs(dir: string): UiPrefs {
 	if (typeof doc.model === "string") prefs.model = doc.model;
 	if (typeof doc.thinking === "string") prefs.thinking = doc.thinking;
 	if (typeof doc.launcher === "string") prefs.launcher = doc.launcher;
+	if (typeof doc.host === "string") prefs.host = doc.host;
+	if (typeof doc.heldJobsNotice === "string") prefs.heldJobsNotice = doc.heldJobsNotice;
+	if (typeof doc.toolsCapNotice === "string") prefs.toolsCapNotice = doc.toolsCapNotice;
+	if (typeof doc.lastPage === "string") prefs.lastPage = doc.lastPage;
 	return prefs;
 }
 

package/src/watch-plan.ts

@@ -0,0 +1,174 @@
+/**
+ * A watch from one sentence, as a question: what `cron_create` and `new_trigger` ask the person
+ * through pi's own `select` before they create anything, in the person's own turn on every surface
+ * (docs/design.md decision 24). The plan, the card it is shown as, the dialog's title and options,
+ * and the one place an answer becomes the stores' fields (`watchChoice`). Pure, beside tools.ts,
+ * the job-edit.ts pattern: the tool asks, maps the answer and creates.
+ */
+import { dangerousCommandReason } from "./danger.ts";
+import { redact } from "./redact.ts";
+import { computeNext, formatDuration, formatLocal, formatSchedule, stamp } from "./schedule.ts";
+import type { LoopJob } from "./store.ts";
+import type { CreateJobInput } from "./tools.ts";
+
+export type WatchWhere = "chat" | "inbox";
+/** What the person cannot change on the card. `stateful` and `verify` follow the answer, so nothing holds the same choice twice; `verify` here is only what the model asked for, the first option's default. */
+export type JobDraft = Omit<CreateJobInput, "stateful" | "recipe">;
+export interface RuleDraft {
+	condition: string;
+	action: string;
+	cwd: string;
+	sessionId?: string;
+	model?: string;
+	thinking?: string;
+}
+export type WatchPlan =
+	| { kind: "schedule"; job: JobDraft; where: WatchWhere }
+	| { kind: "rule"; rule: RuleDraft; where: WatchWhere; once: boolean };
+
+/** What the card shows, computed once here: the page parses no schedule. */
+export interface WatchCard {
+	kind: WatchPlan["kind"];
+	/** "every day at 09:00" for a schedule; the condition for a rule. */
+	when: string;
+	/** A schedule's next run, in local time. */
+	next?: string;
+	/** A rule: how often the background looks (`[triggers] poll_interval_secs`). */
+	looksEverySecs?: number;
+	/** The action, whole, redacted: the card is the consent, so it shows all of what would run. */
+	does: string;
+	/** A loop that asks for a checker: each finding is reviewed before it enters the inbox. */
+	verify?: boolean;
+	/** Why the unattended policy would refuse the action's command, when it would. */
+	danger?: string;
+	/** The terminal line that would do the same, whole and redacted. */
+	command: string;
+}
+/** A schedule in words, for the card's first row; an expression with no short reading is shown as it is. */
+export function scheduleWords(schedule: LoopJob["schedule"]): string {
+	if (schedule.kind !== "cron") return formatSchedule(schedule);
+	const f = schedule.expr.trim().split(/\s+/);
+	if (f.length !== 5) return schedule.expr;
+	const [minute, hour, dom, month, dow] = f;
+	const plain = (v: string) => /^\d{1,2}$/.test(v);
+	const hhmm = () => `${hour.padStart(2, "0")}:${minute.padStart(2, "0")}`;
+	if (plain(minute) && plain(hour) && dom === "*" && month === "*") {
+		if (dow === "*") return `every day at ${hhmm()}`;
+		if (dow === "1-5" || dow === "mon-fri") return `weekdays at ${hhmm()}`;
+		if (dow === "1" || dow === "mon") return `every Monday at ${hhmm()}`;
+	}
+	const step = /^\*\/(\d+)$/.exec(minute);
+	if (step && hour === "*" && dom === "*" && month === "*" && dow === "*") return `every ${step[1]} minutes`;
+	if (minute === "0" && hour === "*" && dom === "*" && month === "*" && dow === "*") return "every hour";
+	return schedule.expr;
+}
+
+const BACKTICK = String.fromCharCode(96);
+const CODE_SPAN = new RegExp(`${BACKTICK}([^${BACKTICK}]+)${BACKTICK}`, "g");
+
+/** The unattended policy's reason over the action and each `code span` in it, when there is one. */
+export function actionDanger(action: string, home?: string): string | undefined {
+	const candidates = [action, ...[...action.matchAll(CODE_SPAN)].map((m) => m[1])];
+	for (const c of candidates) {
+		const reason = dangerousCommandReason(c, home);
+		if (reason) return reason;
+	}
+	return undefined;
+}
+
+/** The terminal line that would do the same, whole and redacted: one line, since that is how it would be typed. */
+const oneLine = (text: string) => redact(text).replace(/\s+/g, " ").trim();
+
+/** What the card says, from the plan: the schedule in words and its next run, or the condition and how often the background looks. */
+export function planCard(plan: WatchPlan, ctx: { now: number; pollSecs: number; home?: string }): WatchCard {
+	if (plan.kind === "schedule") {
+		const next = computeNext({ schedule: plan.job.schedule, createdAt: ctx.now }, ctx.now);
+		const spec = plan.job.schedule.kind === "cron" ? plan.job.schedule.expr : plan.job.schedule.kind === "every" ? `every ${formatDuration(plan.job.schedule.ms)}` : `at ${stamp(plan.job.schedule.at).slice(0, 16)}`;
+		return {
+			kind: "schedule",
+			when: scheduleWords(plan.job.schedule),
+			next: next === undefined ? undefined : formatLocal(next),
+			does: redact(plan.job.prompt),
+			verify: plan.job.verify || undefined,
+			danger: actionDanger(plan.job.prompt, ctx.home),
+			command: oneLine(`/cron add${plan.where === "inbox" ? " --stateful" : ""}${plan.job.name ? ` --name ${plan.job.name}` : ""} "${spec}" ${plan.job.prompt}`),
+		};
+	}
+	return {
+		kind: "rule",
+		when: redact(plan.rule.condition),
+		looksEverySecs: ctx.pollSecs,
+		does: redact(plan.rule.action),
+		danger: actionDanger(plan.rule.action, ctx.home),
+		// A condition the model wrote as "when …" already has its word.
+		command: oneLine(`/new-trigger when ${plan.rule.condition.replace(/^\s*when\s+/i, "")}, ${plan.rule.action}`),
+	};
+}
+
+/** The dialog's first line: how the page tells a watch question from any other select. */
+export const WATCH_ASK_HEAD = "Set up this watch?";
+/** How long the question waits for the person before pi cancels it and the tool says so. */
+export const WATCH_ASK_MS = 30 * 60_000;
+export const WATCH_CANCEL = "Cancel";
+
+/** "every 10 minutes": how often the background looks, as the card says it. */
+function looksWords(secs: number): string {
+	return secs >= 120 ? `every ${Math.round(secs / 60)} minutes` : secs === 60 ? "every minute" : `every ${secs} seconds`;
+}
+
+/**
+ * The dialog's title: the head line, then the card's rows as `Label: value`, the same text a
+ * terminal shows and the page draws its card from. A value's further lines are indented two spaces,
+ * so a line inside an action never reads as a row of its own.
+ */
+export function askTitle(card: WatchCard): string {
+	const rows: [string, string][] = [];
+	if (card.kind === "rule") {
+		rows.push(["Waits for", card.when], ["Looks", looksWords(card.looksEverySecs ?? 600)]);
+		rows.push(["Then", card.does]);
+	} else {
+		rows.push(["Runs", `${card.when}${card.next ? ` · next ${card.next}` : ""}`], ["Does", card.does]);
+	}
+	if (card.danger) rows.push(["Careful", `When this runs nobody is asked: pi-loops refuses ${card.danger} and does the safe part.`]);
+	rows.push(["Command", card.command]);
+	return [WATCH_ASK_HEAD, ...rows.map(([label, value]) => `${label}: ${value.replace(/\r?\n/g, "\n  ")}`)].join("\n");
+}
+
+/** A yes, as the card's choices: where the result goes, whether a rule fires once, whether a loop's findings are checked. */
+export type WatchChoice = { verdict: "cancel" } | { verdict: "set"; where: WatchWhere; once: boolean; checks: boolean };
+type SetChoice = Extract<WatchChoice, { verdict: "set" }>;
+
+const WHERE_WORDS: Record<WatchWhere, string> = { chat: "this conversation", inbox: "inbox" };
+const SCHEDULE_CHOICES: SetChoice[] = [
+	{ verdict: "set", where: "inbox", once: true, checks: false },
+	{ verdict: "set", where: "inbox", once: true, checks: true },
+	{ verdict: "set", where: "chat", once: true, checks: false },
+];
+const RULE_CHOICES: SetChoice[] = [
+	{ verdict: "set", where: "chat", once: true, checks: false },
+	{ verdict: "set", where: "chat", once: false, checks: false },
+	{ verdict: "set", where: "inbox", once: true, checks: false },
+	{ verdict: "set", where: "inbox", once: false, checks: false },
+];
+function optionText(kind: WatchPlan["kind"], c: SetChoice): string {
+	const extra = kind === "rule" ? (c.once ? " · once" : " · every time") : c.checks ? " · with checks" : "";
+	return `Set it up · ${WHERE_WORDS[c.where]}${extra}`;
+}
+/** Every answer that sets a watch up, and what it means: the whole vocabulary, so nothing else parses. */
+const VOCABULARY = new Map<string, SetChoice>([...SCHEDULE_CHOICES.map((c) => [optionText("schedule", c), c] as const), ...RULE_CHOICES.map((c) => [optionText("rule", c), c] as const)]);
+
+/**
+ * The dialog's options: one per combination of the card's choices, so the page's chips are the axes
+ * of this set and Set it up sends the one option they name. The same strings every time; the plan's
+ * own defaults come first, which is what a terminal's selector highlights and the page's chips start on.
+ */
+export function watchOptions(plan: WatchPlan): string[] {
+	const all = plan.kind === "rule" ? RULE_CHOICES : SCHEDULE_CHOICES;
+	const first = plan.kind === "rule" ? all.find((c) => c.where === plan.where && c.once === plan.once)! : all.find((c) => c.where === plan.where && c.checks === (plan.where === "inbox" && plan.job.verify === true))!;
+	return [first, ...all.filter((c) => c !== first)].map((c) => optionText(plan.kind, c)).concat(WATCH_CANCEL);
+}
+
+/** The answer pi's select gave (`undefined` for Esc, an abort or the timeout), as the card's choices. Anything outside the vocabulary is a cancel. */
+export function watchChoice(answer: string | undefined): WatchChoice {
+	return (answer !== undefined && VOCABULARY.get(answer)) || { verdict: "cancel" };
+}

package/src/web.d.mts

@@ -0,0 +1,3 @@
+export const DOOR: string;
+export const ICON: string;
+export const PAGE: string;