pi-lean-portal 0.1.0

package/backends/python-base/pi_browser_bridge/transport.py

@@ -0,0 +1,167 @@
+"""
+JSON-RPC 2.0 transport over stdin/stdout for the Python bridge.
+
+Protocol:
+- Each message is a single JSON-RPC 2.0 request or response, one per line.
+- Requests use newline-delimited framing (each JSON object on one line).
+- Responses are written to stdout as a single JSON line, then flushed.
+
+Request format::
+
+    {"jsonrpc":"2.0","method":"browser.navigate","params":{...},"id":1}
+
+Success response::
+
+    {"jsonrpc":"2.0","result":{...},"id":1}
+
+Error response::
+
+    {"jsonrpc":"2.0","error":{"code":-32000,"message":"...","data":{...}},"id":1}
+"""
+
+import json
+import sys
+import traceback
+from typing import Any, Optional
+
+
+# ─── Standard JSON-RPC error codes ────────────────────────────────────
+
+PARSE_ERROR = -32700
+INVALID_REQUEST = -32600
+METHOD_NOT_FOUND = -32601
+INVALID_PARAMS = -32602
+INTERNAL_ERROR = -32603
+
+# Custom error codes (application-level)
+APPLICATION_ERROR = -32000
+TIMEOUT_ERROR = -32001
+SESSION_ERROR = -32002
+
+
+# ─── Custom exceptions ────────────────────────────────────────────────
+
+
+class InvalidRequestError(ValueError):
+    """Raised when a request has valid JSON but is not a valid JSON-RPC
+    Request object (e.g. missing ``jsonrpc`` or ``method`` fields).
+    """
+
+
+# ─── Reading requests ─────────────────────────────────────────────────
+
+def read_request() -> Optional[dict[str, Any]]:
+    """Read one JSON-RPC request from stdin (line-delimited).
+
+    Returns the parsed request dict, or None on EOF.
+    Raises ValueError on JSON parse failure.
+    Raises InvalidRequestError on structural validation failure.
+    """
+    # Skip empty lines (heartbeats), stop at EOF
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            return None  # EOF
+        line = line.strip()
+        if line:
+            break  # non-empty line found
+
+    try:
+        request: dict[str, Any] = json.loads(line)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Failed to parse JSON-RPC request: {exc}") from exc
+
+    # Validate basic JSON-RPC structure
+    if not isinstance(request, dict):
+        raise InvalidRequestError("JSON-RPC request must be a JSON object")
+
+    if request.get("jsonrpc") != "2.0":
+        raise InvalidRequestError('Missing or invalid "jsonrpc": "2.0" field')
+
+    if "method" not in request or not isinstance(request.get("method"), str):
+        raise InvalidRequestError('Missing or invalid "method" field')
+
+    return request
+
+
+# ─── Writing responses ────────────────────────────────────────────────
+
+def write_response(response: dict[str, Any]) -> None:
+    """Write a JSON-RPC response to stdout as a single JSON line, then flush.
+
+    The response should already be a complete JSON-RPC response dict
+    (with ``jsonrpc``, ``id``, and either ``result`` or ``error``).
+    """
+    line = json.dumps(response, ensure_ascii=False, default=str)
+    sys.stdout.write(line + "\n")
+    sys.stdout.flush()
+
+
+def make_success_response(request_id: Any, result: Any) -> dict[str, Any]:
+    """Build a JSON-RPC success response."""
+    return {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "result": result,
+    }
+
+
+def make_error_response(
+    request_id: Any,
+    code: int,
+    message: str,
+    data: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    """Build a JSON-RPC error response."""
+    error: dict[str, Any] = {
+        "code": code,
+        "message": message,
+    }
+    if data is not None:
+        error["data"] = data
+    return {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "error": error,
+    }
+
+
+def make_parse_error(request_id: Any = None) -> dict[str, Any]:
+    """Build a JSON-RPC parse error response."""
+    return make_error_response(request_id, PARSE_ERROR, "Parse error")
+
+
+def make_invalid_request(request_id: Any = None) -> dict[str, Any]:
+    """Build a JSON-RPC invalid request response."""
+    return make_error_response(request_id, INVALID_REQUEST, "Invalid Request")
+
+
+def make_internal_error(
+    request_id: Any,
+    exc: Exception,
+) -> dict[str, Any]:
+    """Build an internal error response including Python traceback."""
+    tb = traceback.format_exception(type(exc), exc, exc.__traceback__)
+    return make_error_response(
+        request_id,
+        INTERNAL_ERROR,
+        f"Internal error: {exc}",
+        data={"traceback": "".join(tb)},
+    )
+
+
+def make_application_error(
+    request_id: Any,
+    message: str,
+    traceback_str: Optional[str] = None,
+) -> dict[str, Any]:
+    """Build an application-level error response."""
+    data: dict[str, Any] = {}
+    if traceback_str:
+        data["traceback"] = traceback_str
+    return make_error_response(
+        request_id,
+        APPLICATION_ERROR,
+        message,
+        data=data or None,
+    )

package/backends/python-base/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pi-browser-bridge"
+version = "0.1.0"
+description = "Shared Python bridge library for pi-lean-portal browser automation plugins"
+requires-python = ">=3.10"
+dependencies = ["playwright>=1.50"]
+
+[tool.pytest.ini_options]
+minversion = "9.0"
+testpaths = ["tests"]
+pythonpath = ["pi_browser_bridge"]

package/browser-cookies.ts

@@ -0,0 +1,88 @@
+/**
+ * Browser Cookies management — extracted from browser-toggle.ts.
+ *
+ * Provides the `/web cookies` subcommand handler for inspecting and
+ * clearing session cookies via the router.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import * as router from "./core/router.js";
+import { taskId } from "./core/shared/task-id.js";
+
+// ─── Handler ─────────────────────────────────────────────────────
+
+/**
+ * Handle the `/web cookies` subcommand.
+ *
+ * @param sub  The sub-command text after "cookies" (e.g. "", "list", "clear --confirm")
+ * @param ctx  The extension context (for UI notifications)
+ */
+export async function handleCookiesSubcommand(
+	sub: string,
+	ctx: ExtensionContext,
+): Promise<void> {
+	if (sub === "" || sub === "list") {
+		const result = await router.getCookies(
+			taskId(ctx as { sessionManager?: { getSessionId?(): string } }),
+		);
+		if (!result.success) {
+			ctx.ui.notify(
+				`Failed to get cookies: ${result.error ?? "unknown error"}`,
+				"warning",
+			);
+			return;
+		}
+		if (result.cookies.length === 0) {
+			ctx.ui.notify("No cookies found for the current session.", "info");
+			return;
+		}
+		// Format cookies
+		const lines = [`Found ${result.cookies.length} cookie(s):`, ""];
+		for (const c of result.cookies) {
+			const flags = [
+				c.httpOnly ? "HttpOnly" : "",
+				c.secure ? "Secure" : "",
+				c.sameSite || "",
+			]
+				.filter(Boolean)
+				.join(" ");
+			const expires =
+				c.expires && c.expires > 0
+					? new Date(c.expires * 1000).toISOString()
+					: "Session";
+			lines.push(
+				`  ${c.name}=${c.value.slice(0, 80)}${c.value.length > 80 ? "…" : ""}`,
+			);
+			lines.push(`    Domain: ${c.domain ?? "?"}  Path: ${c.path ?? "/"}`);
+			lines.push(`    Expires: ${expires}  ${flags}`.trimEnd());
+			lines.push("");
+		}
+		ctx.ui.notify(lines.join("\n"), "info");
+	} else if (sub === "clear" || sub === "clear --confirm") {
+		if (sub === "clear") {
+			ctx.ui.notify(
+				"⚠ This will clear ALL cookies for the current session.\n" +
+					"  Run /web cookies clear --confirm to proceed.",
+				"warning",
+			);
+			return;
+		}
+		const result = await router.clearCookies(
+			taskId(ctx as { sessionManager?: { getSessionId?(): string } }),
+		);
+		if (!result.success) {
+			ctx.ui.notify(
+				`Failed to clear cookies: ${result.error ?? "unknown error"}`,
+				"warning",
+			);
+			return;
+		}
+		ctx.ui.notify("Cleared all cookies for the current session.", "info");
+	} else {
+		ctx.ui.notify(
+			`Unknown cookies sub-command: "${sub}". ` +
+				`Usage: /web cookies [list|clear [--confirm]]`,
+			"warning",
+		);
+	}
+}

package/browser-profile.ts

@@ -0,0 +1,260 @@
+/**
+ * Browser Profile management — extracted from browser-toggle.ts.
+ *
+ * Provides profile listing, formatting, and the `/web profile` subcommand
+ * handler.  Stateful operations (setting the conversation-scoped default
+ * profile) are delegated through a callback to avoid circular dependency
+ * with browser-toggle.ts's internal state.
+ */
+
+import type {
+	ExtensionContext,
+	ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+import { existsSync, readdirSync, statSync, mkdirSync } from "node:fs";
+import {
+	PROFILE_DIR,
+	profileFilePath,
+	deleteStorageState,
+	pruneStaleSessionProfiles,
+	isSessionProfile,
+	sanitizeProfileName,
+	profileDir,
+} from "./core/shared/storage-state.js";
+
+// ─── Profile helpers ─────────────────────────────────────────────
+
+/**
+ * Get a human-readable size description for a profile's storage state.
+ * Returns "no state" if the file doesn't exist or is empty.
+ */
+export function profileStateSize(profileName: string): string {
+	const path = profileFilePath(profileName);
+	try {
+		if (!existsSync(path)) return "no state";
+		const bytes = statSync(path).size;
+		if (bytes === 0) return "empty";
+		if (bytes < 1024) return `${bytes} B`;
+		if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+		return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	} catch {
+		return "?";
+	}
+}
+
+/**
+ * List all profiles found on disk.
+ * Returns an array of { name, stateSize } objects.
+ */
+export function listProfiles(): Array<{
+	name: string;
+	stateSize: string;
+}> {
+	try {
+		if (!existsSync(PROFILE_DIR)) return [];
+		const entries = readdirSync(PROFILE_DIR, { withFileTypes: true });
+		const profiles = entries
+			.filter((e) => e.isDirectory() && !e.name.startsWith("."))
+			.map((e) => ({
+				name: e.name,
+				stateSize: profileStateSize(e.name),
+			}));
+		profiles.sort((a, b) => a.name.localeCompare(b.name));
+		return profiles;
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Short human-readable label for a profile name.
+ * Session-scoped profiles show "📋" instead of the raw `_session-` prefix.
+ * Named profiles show as-is.
+ */
+export function profileLabel(name: string): string {
+	if (isSessionProfile(name)) return "📋 session";
+	return name;
+}
+
+/**
+ * Format a profile list as a human-readable string.
+ */
+export function formatProfileList(
+	profiles: ReturnType<typeof listProfiles>,
+): string {
+	if (profiles.length === 0) {
+		return "No profiles found on disk.";
+	}
+	const lines = [`Profiles (${profiles.length}):`];
+	for (const p of profiles) {
+		const sessionBadge = isSessionProfile(p.name) ? " 📋" : "";
+		lines.push(`  ${profileLabel(p.name)}  (${p.stateSize})${sessionBadge}`);
+	}
+	return lines.join("\n");
+}
+
+// ─── Profile subcommand handler ──────────────────────────────────
+
+/**
+ * Handle the `/web profile` subcommand.
+ *
+ * @param sub     The sub-command text after "profile" (e.g. "", "list", "create shopping")
+ * @param ctx     The extension context (for UI notifications)
+ * @param pi      The ExtensionAPI (for tool state queries)
+ * @param setConversationDefaultProfile  Callback setter — accepts "none" or a profile name
+ */
+export async function handleProfileSubcommand(
+	sub: string,
+	ctx: ExtensionContext,
+	_pi: ExtensionAPI,
+	setConversationDefaultProfile: (profile: string) => void,
+): Promise<void> {
+	// --- list (default) ---
+	if (sub === "" || sub === "list") {
+		const profiles = listProfiles();
+		const formatted = formatProfileList(profiles);
+		ctx.ui.notify(formatted, "info");
+
+		// --- mode switches (special keywords) ---
+	} else if (sub === "none") {
+		setConversationDefaultProfile("none");
+		ctx.ui.notify(
+			"Default profile set to 'none' (ephemeral, no persistence).",
+			"info",
+		);
+	} else if (sub === "session") {
+		setConversationDefaultProfile("session");
+		ctx.ui.notify(
+			"Default profile set to 'session' (persists for this conversation).",
+			"info",
+		);
+
+		// --- create <name> ---
+	} else if (sub === "create" || sub.startsWith("create ")) {
+		const name = sub === "create" ? "" : sub.slice("create ".length).trim();
+		if (!name) {
+			ctx.ui.notify(
+				"Usage: /web profile create <name>\n" +
+					"  Profile names must be alphanumeric, hyphens, and underscores only.\n" +
+					"  Reserved names: none, session, create, list, clear, clear-all, prune.",
+				"warning",
+			);
+			return;
+		}
+		try {
+			sanitizeProfileName(name);
+			mkdirSync(profileDir(name), { recursive: true, mode: 0o700 });
+			ctx.ui.notify(
+				`Created profile '${name}'. Use browser-navigate profile="${name}" to start.`,
+				"info",
+			);
+		} catch (err) {
+			ctx.ui.notify(
+				`Invalid profile name: ${err instanceof Error ? err.message : String(err)}`,
+				"warning",
+			);
+		}
+
+		// --- prune [--confirm] ---
+	} else if (sub === "prune" || sub === "prune --confirm") {
+		const result = pruneStaleSessionProfiles();
+		if (result.pruned.length === 0) {
+			ctx.ui.notify("No stale session profiles to prune.", "info");
+			return;
+		}
+		if (sub === "prune") {
+			ctx.ui.notify(
+				`Found ${result.pruned.length} stale session profile(s): ${result.pruned.join(", ")}\n` +
+					`  Run /web profile prune --confirm to delete.`,
+				"warning",
+			);
+		} else {
+			ctx.ui.notify(
+				`Pruned ${result.pruned.length} stale session profile(s).`,
+				"info",
+			);
+		}
+
+		// --- switch to existing named profile ---
+	} else if (
+		!sub.includes(" ") &&
+		sub !== "clear" &&
+		sub !== "clear-all" &&
+		sub !== "prune"
+	) {
+		// Single word that isn't a known keyword — try as a named profile switch
+		try {
+			const targetDir = profileDir(sub);
+			if (!existsSync(targetDir)) {
+				ctx.ui.notify(
+					`Profile '${sub}' does not exist.\n` +
+						`  Create it first with /web profile create ${sub}`,
+					"warning",
+				);
+				return;
+			}
+			setConversationDefaultProfile(sub);
+			ctx.ui.notify(
+				`Default profile set to '${sub}' (shared across tasks).`,
+				"info",
+			);
+		} catch (err) {
+			ctx.ui.notify(
+				`Invalid profile name: ${err instanceof Error ? err.message : String(err)}`,
+				"warning",
+			);
+		}
+
+		// --- clear <name> ---
+	} else if (sub === "clear" || sub.startsWith("clear ")) {
+		const name = sub === "clear" ? "" : sub.slice("clear ".length).trim();
+		if (!name) {
+			ctx.ui.notify(
+				"Usage: /web profile clear <name> — provide a profile name.",
+				"warning",
+			);
+			return;
+		}
+		const path = profileFilePath(name);
+		if (!existsSync(path)) {
+			ctx.ui.notify(
+				`Profile '${name}' has no saved state. Nothing to clear.`,
+				"info",
+			);
+			return;
+		}
+		deleteStorageState(name);
+		ctx.ui.notify(`Cleared profile '${name}' state.`, "info");
+
+		// --- clear-all [--confirm] ---
+	} else if (sub === "clear-all" || sub === "clear-all --confirm") {
+		const profiles = listProfiles();
+		if (profiles.length === 0) {
+			ctx.ui.notify("No profiles to clear.", "info");
+			return;
+		}
+		if (sub === "clear-all") {
+			const names = profiles.map((p) => p.name).join(", ");
+			ctx.ui.notify(
+				`⚠ This will clear ALL profile states: ${names}\n` +
+					`  Run /web profile clear-all --confirm to proceed.`,
+				"warning",
+			);
+		} else {
+			let cleared = 0;
+			for (const p of profiles) {
+				deleteStorageState(p.name);
+				cleared++;
+			}
+			ctx.ui.notify(`Cleared ${cleared} profile(s).`, "info");
+		}
+
+		// --- unknown ---
+	} else {
+		ctx.ui.notify(
+			`Unknown profile sub-command: "${sub}". ` +
+				`Usage: /web profile [list|create <name>|<name>|none|session|clear <name>|clear-all [--confirm]|prune [--confirm]]`,
+			"warning",
+		);
+	}
+}

package/browser-status.ts

@@ -0,0 +1,84 @@
+/**
+ * Browser Status — /web status subcommand.
+ *
+ * Combines toggle state (browser on/off, learn on/off) with runtime state
+ * (backend health, active sessions, plugins, profiles on disk).
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { sessionManager } from "./core/shared/session-manager.js";
+import { pluginRegistry } from "./core/plugin-registry.js";
+import { listProfiles } from "./browser-profile.js";
+import { isSessionProfile } from "./core/shared/storage-state.js";
+
+/**
+ * Show detailed browser runtime status.
+ *
+ * @param browserOn - whether browser tools are currently active in context
+ * @param learnOn   - whether learn tools are currently active in context
+ */
+export function handleStatusSubcommand(
+	ctx: ExtensionContext,
+	browserOn: boolean,
+	learnOn: boolean,
+): void {
+	const status = sessionManager.getStatus();
+	const active = sessionManager.getActiveSessions();
+
+	let msg = `🌐 Browser tools: ${browserOn ? "✅ on" : "❌ off"}`;
+	msg += `  |  📖 Learn mode: ${learnOn ? "✅ on" : "❌ off"}`;
+	msg += `\n────────────────────────────────────────`;
+	msg += `\nStatus: ${status}`;
+
+	// List available plugins
+	const allPlugins = pluginRegistry.availableAll();
+	const backendLines: string[] = [];
+	for (const p of allPlugins) {
+		if (p.enabled) {
+			backendLines.push(p.name);
+		} else {
+			backendLines.push(`${p.name} (disabled)`);
+		}
+	}
+	msg += `\nPlugins: ${backendLines.join(", ")}`;
+	msg += `\nUse web-fetch for stateless HTTP fetches.`;
+
+	if (active.length > 0) {
+		msg += `\nActive sessions: ${active.length}`;
+		for (const s of active) {
+			const sym = sessionManager.pluginSymbol(s.pluginName);
+			msg += `\n  ${sym} [${s.pluginName}] ${s.currentUrl || "(pending)"}`;
+			if (s.currentTitle) msg += ` — ${s.currentTitle}`;
+			if (s.profileName) msg += ` [profile: ${s.profileName}]`;
+		}
+	}
+
+	// Profiles section
+	// Session profiles (auto-generated `_session-*`) are ephemeral and
+	// not user-named — they clutter the dashboard, so they are collapsed
+	// into a single summary line. Named profiles get full rows. Use
+	// `/web profile list` to inspect individual session profiles.
+	const profiles = listProfiles();
+	const named = profiles.filter((p) => !isSessionProfile(p.name));
+	const session = profiles.filter((p) => isSessionProfile(p.name));
+	const activeProfile = active.find((s) => s.profileName)?.profileName;
+
+	if (named.length > 0) {
+		const lines = [`\nProfiles: ${named.length} on disk (named)`];
+		for (const p of named) {
+			const current = p.name === activeProfile ? " ← active" : "";
+			lines.push(`  ${p.name}  (${p.stateSize})${current}`);
+		}
+		msg += lines.join("\n");
+	} else if (session.length === 0) {
+		msg += `\nProfiles: none`;
+	}
+
+	if (session.length > 0) {
+		const activeSession = session.some((p) => p.name === activeProfile);
+		const tag = activeSession ? " (active)" : "";
+		msg += `\nSession profiles: ${session.length}${tag} (manage with /web profile)`;
+	}
+
+	ctx.ui.notify(msg, "info");
+}