@workweave/router 0.1.7 → 0.2.0

package/pi-router/src/index.ts

@@ -0,0 +1,49 @@
+/**
+ * @workweave/router — route the pi coding agent through the WorkWeave Router.
+ *
+ * Wiring (all on the existing router surface — no router source change beyond
+ * the installer):
+ *   - provider:     register `weave` with per-process knob headers (quality on
+ *                   the main loop, speed/cheap in subagents).
+ *   - metadata:     stamp body.metadata.user_id for sticky sessions + subagent
+ *                   detection.
+ *   - routed-model: show which model the router actually picked.
+ *   - safety:       block catastrophic bash (unless WEAVE_NO_SAFETY=1).
+ *   - compaction:   experimental cheap path (only when WEAVE_CHEAP_COMPACTION=1).
+ *   - dispatch:     parallel, context-isolated subagents — top-level process
+ *                   only (no grandchildren).
+ *
+ * The same module loads in dispatched children via `-e <self>`; WEAVE_PI_SUBAGENT
+ * flips the provider knobs and suppresses the dispatch tool so fan-out doesn't recurse.
+ */
+
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { isSubagent } from "./config.js";
+import { registerCheapCompaction } from "./compaction.js";
+import { registerDispatch } from "./dispatch.js";
+import { registerMetadata } from "./metadata.js";
+import { registerRoutedModel } from "./routed-model.js";
+import { registerSafety } from "./safety.js";
+import { registerWeave } from "./provider.js";
+
+const SELF_PATH = fileURLToPath(import.meta.url);
+
+export default function (pi: ExtensionAPI): void {
+	// Register at load so the provider is available for `--list-models` and
+	// print mode (dispatched children), and again on session_start so the right
+	// knob headers survive `/reload` and new/resumed sessions.
+	registerWeave(pi);
+	pi.on("session_start", () => registerWeave(pi));
+
+	registerMetadata(pi);
+	registerRoutedModel(pi);
+
+	if (process.env.WEAVE_NO_SAFETY !== "1") registerSafety(pi);
+	if (process.env.WEAVE_CHEAP_COMPACTION === "1") registerCheapCompaction(pi);
+
+	// Only the top-level process fans out. Children (WEAVE_PI_SUBAGENT=1) load
+	// this same extension but get no dispatch tool, so subagents can't spawn
+	// grandchildren.
+	if (!isSubagent()) registerDispatch(pi, SELF_PATH);
+}

package/pi-router/src/metadata.ts

@@ -0,0 +1,32 @@
+/**
+ * Injects `metadata.user_id` into the request body so the router can:
+ *   - keep the main loop on a sticky session pin ("pi:<sessionId>"), and
+ *   - detect subagents ("subagent:<uuid>") for an independent pin + server-side
+ *     SubAgentDispatch handling.
+ *
+ * This is the one body-level signal we control (the session pin key derives
+ * from metadata.user_id when present; subagent detection on the Anthropic
+ * ingress path keys off a "subagent:" prefix). Headers can't carry it because
+ * before_provider_request can't set headers.
+ */
+
+import { randomUUID } from "node:crypto";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { isSubagent } from "./config.js";
+
+// One id per child process so all of a subagent's requests share a single pin.
+// The parent passes WEAVE_PI_SUBAGENT_ID; a standalone child falls back to a uuid.
+const SUBAGENT_USER_ID = `subagent:${process.env.WEAVE_PI_SUBAGENT_ID?.trim() || randomUUID()}`;
+
+export function registerMetadata(pi: ExtensionAPI): void {
+	pi.on("before_provider_request", (event, ctx: ExtensionContext) => {
+		const body = event.payload as { metadata?: { user_id?: string } } | undefined;
+		if (!body || typeof body !== "object") return undefined;
+
+		const userId = isSubagent() ? SUBAGENT_USER_ID : `pi:${ctx.sessionManager.getSessionId()}`;
+		if (body.metadata?.user_id === userId) return undefined;
+
+		body.metadata = { ...(body.metadata ?? {}), user_id: userId };
+		return body;
+	});
+}

package/pi-router/src/provider.ts

@@ -0,0 +1,51 @@
+/**
+ * Registers the `weave` provider with the per-process header policy.
+ *
+ * Re-registered on each `session_start` (and once at load) so the right knob
+ * headers are always live and the provider survives `/reload`. We register a
+ * new provider named "weave" rather than overriding the built-in "anthropic"
+ * provider — overriding "anthropic" would hijack the Claude OAuth token.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	getRole,
+	getRouterBaseUrl,
+	isSubagent,
+	PROVIDER_NAME,
+	providerHeaders,
+	resolveRouterKey,
+	WEAVE_MODELS,
+} from "./config.js";
+
+export function registerWeave(pi: ExtensionAPI): void {
+	const key = resolveRouterKey();
+	const role = getRole();
+
+	if (!key) {
+		// The main loop can still run off the installer-written models.json
+		// provider. A subagent MUST apply the speed/cheap knobs, so a missing
+		// key there is fatal rather than silently routing on quality knobs.
+		if (isSubagent()) {
+			throw new Error(
+				"Weave: no router key found (set WEAVE_ROUTER_KEY or write ~/.pi/agent/.weave_router_key).",
+			);
+		}
+		return;
+	}
+
+	pi.registerProvider(PROVIDER_NAME, {
+		name: "Weave Router",
+		// Root URL, no /v1: the anthropic-messages provider uses @anthropic-ai/sdk,
+		// which appends /v1/messages to baseUrl. A /v1 here yields /v1/v1/messages.
+		baseUrl: getRouterBaseUrl(),
+		// Planted to satisfy pi's "is auth configured" check. The router ignores
+		// it (auth runs off X-Weave-Router-Key); authHeader:false keeps
+		// Authorization free for BYOK.
+		apiKey: key,
+		api: "anthropic-messages",
+		authHeader: false,
+		headers: providerHeaders(role, key),
+		models: WEAVE_MODELS,
+	});
+}

package/pi-router/src/routed-model.ts

@@ -0,0 +1,31 @@
+/**
+ * Surfaces which model the router actually picked for each request.
+ *
+ * The router sets `x-router-model` on every response (streaming, non-streaming,
+ * and cache hits). In the interactive UI we show it in the status bar and
+ * notify on change. In a headless child (print/RPC — e.g. a dispatch subagent)
+ * there is no UI, so we print a marker to stderr that the parent dispatch tool
+ * parses to attribute each subagent's work to a model.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { ROUTED_MODEL_HEADER, ROUTED_MODEL_STDERR_PREFIX } from "./config.js";
+
+const STATUS_KEY = "weave";
+
+export function registerRoutedModel(pi: ExtensionAPI): void {
+	let last: string | undefined;
+
+	pi.on("after_provider_response", (event, ctx: ExtensionContext) => {
+		const model = event.headers?.[ROUTED_MODEL_HEADER];
+		if (!model || model === last) return;
+		last = model;
+
+		if (ctx.hasUI) {
+			ctx.ui.setStatus(STATUS_KEY, `routed: ${model}`);
+			ctx.ui.notify(`Weave routed to ${model}`, "info");
+		} else {
+			process.stderr.write(`${ROUTED_MODEL_STDERR_PREFIX} ${model}\n`);
+		}
+	});
+}

package/pi-router/src/safety.ts

@@ -0,0 +1,66 @@
+/**
+ * Last-resort guard against a handful of catastrophic, effectively
+ * irreversible shell commands. pi already confirms normal tool calls; this
+ * matters most in non-interactive subagents where there is no human to
+ * confirm. It blocks ONLY the obviously-destructive forms below — it is a
+ * backstop, not a sandbox. Disable with WEAVE_NO_SAFETY=1.
+ */
+
+import { type ExtensionAPI, type ExtensionContext, isToolCallEventType, type ToolCallEvent } from "@mariozechner/pi-coding-agent";
+
+interface Rule {
+	test: (cmd: string) => boolean;
+	reason: string;
+}
+
+const hasRecursive = (c: string) => /(?:\s|^)-\w*r/i.test(c) || /--recursive\b/.test(c);
+const hasForce = (c: string) => /(?:\s|^)-\w*f/i.test(c) || /--force\b/.test(c);
+const targetsRoot = (c: string) =>
+	/--no-preserve-root\b/.test(c) || /(?:\s|^)(?:\/|~|\$HOME|\/\*)(?:\s|$)/.test(c);
+
+const RULES: Rule[] = [
+	{
+		test: (c) => /\brm\b/.test(c) && hasRecursive(c) && hasForce(c) && targetsRoot(c),
+		reason: "recursive force-remove of a root/home path",
+	},
+	{
+		test: (c) => /\bmkfs(\.\w+)?\b/.test(c),
+		reason: "filesystem format (mkfs)",
+	},
+	{
+		test: (c) => /\bdd\b[^\n]*\bof=\/dev\//.test(c),
+		reason: "dd writing directly to a device",
+	},
+	{
+		test: (c) => />\s*\/dev\/(?:sd|nvme|disk|hd|mapper)/.test(c),
+		reason: "redirect overwriting a raw block device",
+	},
+	{
+		test: (c) => /:\s*\(\s*\)\s*\{[^}]*\|[^}]*&[^}]*\}\s*;\s*:/.test(c),
+		reason: "fork bomb",
+	},
+	{
+		test: (c) =>
+			/\bgit\s+push\b/.test(c) &&
+			(/(?:--force(?!-with-lease)|\s-f\b)/.test(c) || /\+(?:main|master)\b/.test(c)) &&
+			/\b(?:main|master)\b/.test(c),
+		reason: "force-push to main/master",
+	},
+];
+
+function catastrophicReason(command: string): string | undefined {
+	const cmd = command.trim();
+	for (const rule of RULES) {
+		if (rule.test(cmd)) return rule.reason;
+	}
+	return undefined;
+}
+
+export function registerSafety(pi: ExtensionAPI): void {
+	pi.on("tool_call", (event: ToolCallEvent, _ctx: ExtensionContext) => {
+		if (!isToolCallEventType("bash", event)) return undefined;
+		const reason = catastrophicReason(event.input.command ?? "");
+		if (!reason) return undefined;
+		return { block: true, reason: `Weave safety: blocked ${reason}. Set WEAVE_NO_SAFETY=1 to override.` };
+	});
+}

package/uninstall.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 #
-# Weave Router uninstaller for Claude Code, Codex, and opencode.
+# Weave Router uninstaller for Claude Code, Codex, opencode, and pi.
 #
 # Default target is Claude Code: removes the env vars, statusLine, and local
 # router auth that install.sh added; leaves the rest of settings.json
@@ -9,12 +9,15 @@
 # config.toml — anything outside the markers is preserved. Pass --opencode
 # to strip the `provider.weave` block (and the top-level `model` key when
 # it points at the router) from opencode.json; other providers and user
-# settings are preserved.
+# settings are preserved. Pass --pi to strip the `weave` provider from
+# pi's models.json, drop @workweave/router from settings.json, revert the
+# weave defaults, and remove the router key file.
 #
 # Usage:
 #   npx @workweave/router --uninstall                            # Claude Code, user scope
 #   npx @workweave/router --uninstall --codex                    # Codex, user scope
 #   npx @workweave/router --uninstall --opencode                 # opencode, user scope
+#   npx @workweave/router --uninstall --pi                       # pi, user scope
 #   npx @workweave/router --uninstall --scope project            # run inside the repo
 #   npx @workweave/router --uninstall --dir /tmp/test            # --dir alone (user scope, .weave/)
 #   npx @workweave/router --uninstall --scope project --dir /tmp # --dir + project scope (.claude/)
@@ -59,6 +62,9 @@ while [ $# -gt 0 ]; do
     --opencode)
       target="opencode"; shift
       ;;
+    --pi)
+      target="pi"; shift
+      ;;
     --claude)
       # No-op selector for symmetry with --codex / --opencode and install.sh's
       # --claude. Lets `./install.sh --uninstall --claude` (which forwards
@@ -77,7 +83,7 @@ while [ $# -gt 0 ]; do
   esac
 done
 
-if { [ "$target" = "claude" ] || [ "$target" = "opencode" ]; } && ! command -v jq >/dev/null 2>&1; then
+if { [ "$target" = "claude" ] || [ "$target" = "opencode" ] || [ "$target" = "pi" ]; } && ! command -v jq >/dev/null 2>&1; then
   err "jq is required for the $target uninstall path."
   exit 1
 fi
@@ -189,6 +195,111 @@ if [ "$target" = "opencode" ]; then
   exit 0
 fi
 
+# ---------- pi uninstall path ----------
+
+if [ "$target" = "pi" ]; then
+  # Resolve the pi agent dir based on scope/dir. Mirrors install.sh: user scope
+  # is pi's default ~/.pi/agent; project/--dir scope is a repo-local .pi.
+  if [ -n "$install_dir" ]; then
+    install_dir="$(cd "$install_dir" 2>/dev/null && pwd || echo "$install_dir")"
+    pi_dir="$install_dir/.pi"
+    refuse_if_symlink "$pi_dir"
+  elif [ "$scope" = "user" ]; then
+    pi_dir="$HOME/.pi/agent"
+  else
+    # Project scope: same prompt + git-root fallback as the opencode path.
+    project_dir=""
+    if [ "$scope_explicit" = "false" ] && [ -r /dev/tty ]; then
+      default_project_dir="$(pwd)"
+      printf "Project directory to uninstall from [default: %s]: " "$default_project_dir"
+      read -r project_dir_choice </dev/tty || project_dir_choice=""
+      project_dir="${project_dir_choice:-$default_project_dir}"
+      case "$project_dir" in
+        "~")    project_dir="$HOME" ;;
+        "~/"*)  project_dir="$HOME/${project_dir#~/}" ;;
+      esac
+      if [ ! -d "$project_dir" ]; then
+        err "directory does not exist: $project_dir"
+        exit 1
+      fi
+      project_dir="$(cd "$project_dir" && pwd)"
+    fi
+    if [ -n "${project_dir:-}" ]; then
+      pi_dir="$project_dir/.pi"
+    else
+      if ! git_root="$(git rev-parse --show-toplevel 2>/dev/null)"; then
+        err "--scope project must be run inside a git repo, or use --dir <path>."
+        exit 1
+      fi
+      pi_dir="$git_root/.pi"
+    fi
+    refuse_if_symlink "$pi_dir"
+  fi
+
+  pi_models_file="$pi_dir/models.json"
+  pi_settings_file="$pi_dir/settings.json"
+  pi_key_file="$pi_dir/.weave_router_key"
+  refuse_if_symlink "$pi_models_file"
+  refuse_if_symlink "$pi_settings_file"
+  refuse_if_symlink "$pi_key_file"
+
+  # models.json: drop provider.weave; remove the file if nothing else remains.
+  # Other providers/models the user added are preserved.
+  if [ -f "$pi_models_file" ]; then
+    cleaned="$(jq '
+      (if .providers.weave then del(.providers.weave) else . end)
+      | (if (.providers // {}) == {} then del(.providers) else . end)
+    ' "$pi_models_file")"
+    printf '%s\n' "$cleaned" >"$pi_models_file"
+    if [ "$(jq -r 'keys | length' "$pi_models_file" 2>/dev/null || echo 0)" = "0" ]; then
+      rm -f "$pi_models_file"
+      ok "Removed empty $pi_models_file"
+    else
+      ok "Cleaned $pi_models_file"
+    fi
+  else
+    info "No pi models config at $pi_models_file (already uninstalled?)"
+  fi
+
+  # settings.json: drop our package and revert defaults that still point at the
+  # router. Leaving defaultProvider="weave" after removing the provider would
+  # break pi startup, so reverting is the correct reverse of the install.
+  # defaultModel is reverted ONLY when defaultProvider was "weave" (the state
+  # install creates): install sets defaultModel only when it was empty, so a user
+  # who independently picked claude-sonnet-4-6 with their own provider keeps it.
+  if [ -f "$pi_settings_file" ]; then
+    cleaned="$(jq '
+      (if .packages then .packages -= ["npm:@workweave/router", "npm:@workweave/pi-router"] else . end)
+      | (if (.packages // []) == [] then del(.packages) else . end)
+      | (if .defaultProvider == "weave"
+           then del(.defaultProvider)
+                | (if .defaultModel == "claude-sonnet-4-6" then del(.defaultModel) else . end)
+           else . end)
+    ' "$pi_settings_file")"
+    printf '%s\n' "$cleaned" >"$pi_settings_file"
+    if [ "$(jq -r 'keys | length' "$pi_settings_file" 2>/dev/null || echo 0)" = "0" ]; then
+      rm -f "$pi_settings_file"
+      ok "Removed empty $pi_settings_file"
+    else
+      ok "Cleaned $pi_settings_file"
+    fi
+  else
+    info "No pi settings at $pi_settings_file (already uninstalled?)"
+  fi
+
+  if [ -f "$pi_key_file" ]; then
+    rm -f "$pi_key_file"
+    ok "Removed $pi_key_file"
+  fi
+
+  if [ -n "$install_dir" ]; then
+    ok "Weave Router uninstalled from $install_dir (pi)."
+  else
+    ok "Weave Router uninstalled (pi, scope=$scope)."
+  fi
+  exit 0
+fi
+
 # ---------- codex uninstall path ----------
 
 if [ "$target" = "codex" ]; then