@skaile/transform-proxy 0.2.5 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.0
+
+- omp extension, **behaviour change**: `/anon on` and `/anon off` switch only the omp process they run in (its subagents and its `/new`, `/resume`, `/fork` sessions included) and no longer save the default. Before, every `/anon on|off` wrote `~/.omp/agent/skaile-transform-proxy.json`, so turning anon off in one window turned it off for every omp started later. `/anon on --global` and `/anon off --global` also save the default. A saved `on` is applied at session start only until the first successful `/anon on|off` in that process, so a plain `/anon off` stays off across `/new`. An existing saved `enabled: true` still turns anon on in new omp processes; run `/anon off --global` to clear it.
+
+## 0.2.6
+
+- omp extension: while anon is on, in error or required, images are not sent. The extension sets omp's `images.blockImages` as a runtime override (never persisted), so omp replaces every image in the request, history included, with `Image reading is disabled.`; `/anon off` drops the override. Before, a screenshot from a browser tool made the proxy refuse every later request of the session with 400 `unsupported_content` ("Anthropic image content cannot be transformed"). `/anon status` lists `images: not sent`. An omp without the settings registry gets one warning, and the proxy keeps refusing images.
+
 ## 0.2.5
 
 - omp extension: the status is `🟢A` (on), `🔴A` (off), `🟠A` (error) instead of `A`, `Ⱥ`, `A!`. The crossed A was not legible in common terminal fonts, and omp strips ANSI colour from extension statuses, so the colour comes from an emoji.

package/README.md

@@ -93,7 +93,7 @@ The package ships an [omp](https://omp.sh) extension (subpath `@skaile/transform
 omp plugin install @skaile/transform-proxy
 ```
 
-It adds the command `/anon on|off|status` and a compact status: `🟢A` (on), `🔴A` (off) or `🟠A` (error). The colour is in the emoji because omp strips ANSI colour from extension statuses and draws them in its accent colour. Unless `SKAILE_TRANSFORM_PROXY_URL` names a running proxy, it needs Node ≥ 22 on `PATH` (or its path in `SKAILE_TRANSFORM_PROXY_NODE`).
+It adds the command `/anon on|off [--global] | status` and a compact status: `🟢A` (on), `🔴A` (off) or `🟠A` (error). The colour is in the emoji because omp strips ANSI colour from extension statuses and draws them in its accent colour. Unless `SKAILE_TRANSFORM_PROXY_URL` names a running proxy, it needs Node ≥ 22 on `PATH` (or its path in `SKAILE_TRANSFORM_PROXY_NODE`).
 
 omp shows extension statuses on an extra line below the status line. To show the status in the status line itself, add the `status` segment and turn the extra line off in `~/.omp/agent/config.yml` (`showHookStatus: false` moves every extension status, not just this one, into the segment):
 
@@ -112,10 +112,12 @@ statusLine:
   - Providers on a wire the proxy does not rewrite (Bedrock, Vertex, Gemini, agent bridges, providers without a base URL) are routed too, so the proxy refuses their requests: the setup fails closed. `/anon status` lists them as refused.
   - The session's active model is rebound to the re-routed one, so the next request already uses the new base URL. A rebind that fails is an activation failure: `/anon on` rolls the routes back, saves nothing and stays off. When anon is required, or a later turn's rebind fails while anon is on, the status shows `🟠A`.
 - While anon is on or in error, a `before_provider_request` handler checks every model request: a request whose model does not target the proxy gets its payload replaced with an empty object, so no conversation text leaves, and an error notice names the model. omp has no hook that cancels a provider request, and a throwing handler is only logged, so this replacement is the block.
+- While anon is on or in error, images are not sent: the extension sets omp's `images.blockImages` in omp's in-memory runtime settings layer, and omp replaces every image in the request, history included, with the note `Image reading is disabled.`. The proxy cannot anonymize images and refuses every request that carries one (400 `unsupported_content`), and omp resends the whole history each turn, so a single screenshot would otherwise block the session. `/anon off` drops the override, so your own `images.blockImages` setting applies again; the override is never written to `config.yml`. An omp without this settings API gets a warning instead, and the proxy keeps refusing images.
 - The proxy session follows the root omp session: on `/new`, `/resume`, `/fork` (`session_switch`) and on a root `session_start` with a new session id, every provider is re-routed with the new `x-skaile-transform-session`. The proxy keeps the old session's state in memory until it exits; no request carries that id again. A `session_start` of a headless `print` session (how omp runs subagents) keeps the parent's id, so subagents share its pseudonyms.
 - `/anon off` restores the original base URLs and headers.
-- `/anon status` shows the state, the proxy URL and its source, the pipeline, the session id, and the routed and refused providers.
-- The enabled flag is saved in `skaile-transform-proxy.json` in omp's agent dir (`~/.omp/agent`; `SKAILE_TRANSFORM_PROXY_OMP_STATE` overrides the path) and re-applied when a session starts.
+- `/anon status` shows the state, the proxy URL and its source, the pipeline, the session id, whether images are blocked, and the routed and refused providers.
+- `/anon on` and `/anon off` switch only the omp process they run in: that window, its subagents, and the sessions it opens with `/new`, `/resume` and `/fork`. Other omp windows are not touched, and the saved default does not change.
+- `/anon on --global` and `/anon off --global` also save the default for omp processes started later, in `skaile-transform-proxy.json` in omp's agent dir (`~/.omp/agent`; `SKAILE_TRANSFORM_PROXY_OMP_STATE` overrides the path). A session start applies a saved `on` until the first successful `/anon on|off` in that process; from then on the process follows its own choice. A failed `/anon on --global` saves nothing.
 - `SKAILE_TRANSFORM_PROXY_MODE=required` (set by a skaile session in required mode) turns routing on at session start and refuses `/anon off`.
 
 The overrides are registered under the model-registry source `skaile-transform-proxy`, so `/anon off` clears them in one catalog reload. A provider that another extension registered at runtime is taken over while anon is on; `/anon off` restores its base URL and headers, and a provider that existed only at runtime is reported as lost (restart omp to restore it).

package/dist/omp/index.d.mts

@@ -59,6 +59,10 @@ interface OmpSessionActions {
   setModel(model: OmpModel): Promise<boolean>;
 }
 interface OmpExtensionApi extends OmpSessionActions {
+  /** omp's package exports; `settings` is the scope its setting handles read and override. */
+  readonly pi?: {
+    readonly settings?: unknown;
+  };
   registerCommand(name: string, options: {
     description?: string;
     getArgumentCompletions?: (argumentPrefix: string) => OmpAutocompleteItem[] | null;
@@ -84,6 +88,14 @@ interface ProxyChildProcess {
   on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
   on(event: 'error', listener: (err: Error) => void): unknown;
 }
+/**
+ * Image sending of the host. The proxy cannot anonymize images and refuses every request that
+ * carries one; omp resends the whole history each turn, so one screenshot would block the session.
+ */
+interface ImageSending {
+  /** `true` stops images from reaching the provider, `false` restores the user's setting. Resolves `false` when the host offers no way to do it; that answer is final. */
+  setBlocked(blocked: boolean): Promise<boolean>;
+}
 interface AnonControllerDeps {
   readonly env: Readonly<Record<string, string | undefined>>;
   readonly home: string;
@@ -95,6 +107,8 @@ interface AnonControllerDeps {
   readonly cliPath?: string;
   /** How long the child may take to print `listening <url>`. Default: 60 s (transform modules may load ML models). */
   readonly listenTimeoutMs?: number;
+  /** Blocked while anon is wanted (on, error or required), released by `/anon off`. Default: none. */
+  readonly images?: ImageSending;
 }
 interface AnonController {
   readonly required: boolean;
@@ -103,7 +117,8 @@ interface AnonController {
   command(args: string, ctx: OmpContext, session: OmpSessionActions): Promise<void>;
   completions(prefix: string): OmpAutocompleteItem[] | null;
   /**
-   * Applies the persisted flag (or required mode) and refreshes the status bar. A root session
+   * Applies the saved default (unless `/anon on|off` already decided in this process) or required
+   * mode, and refreshes the status bar. A root session
    * whose omp session id changed rotates the proxy session; subagents keep the parent's id.
    */
   sessionStart(ctx: OmpContext, session: OmpSessionActions): Promise<void>;
@@ -133,4 +148,6 @@ export declare function defaultStatePath(env: Readonly<Record<string, string | u
 /** Registers the `/anon` command and the event handlers on one session's extension API. */
 export declare function registerAnonExtension(pi: OmpExtensionApi, controller: AnonController): void;
 export default function anonExtension(pi: OmpExtensionApi): void;
-export type { AnonController, AnonControllerDeps, OmpAutocompleteItem, OmpContext, OmpEventName, OmpExtensionApi, OmpModel, OmpModelRegistry, OmpNotifyType, OmpProviderOverride, OmpSessionActions, OmpUi, ProxyChildProcess, ProxySpawnOptions };
+/** Blocks images through a runtime override of omp's `images.blockImages`, which strips them from every request, history included. */
+export declare function ompImageSending(pi: OmpExtensionApi, load?: () => Promise<unknown>): ImageSending;
+export type { AnonController, AnonControllerDeps, ImageSending, OmpAutocompleteItem, OmpContext, OmpEventName, OmpExtensionApi, OmpModel, OmpModelRegistry, OmpNotifyType, OmpProviderOverride, OmpSessionActions, OmpUi, ProxyChildProcess, ProxySpawnOptions };

package/dist/omp/index.mjs

@@ -14,7 +14,7 @@ const TOKEN_ENV = "SKAILE_TRANSFORM_PROXY_TOKEN";
 const NODE_ENV = "SKAILE_TRANSFORM_PROXY_NODE";
 /** `required` (set by a skaile session in required mode): routing is forced on and `/anon off` is refused. */
 const MODE_ENV = "SKAILE_TRANSFORM_PROXY_MODE";
-/** Overrides the path of the persisted enabled flag. */
+/** Overrides the path of the saved default (`/anon on|off --global`). */
 const STATE_ENV = "SKAILE_TRANSFORM_PROXY_OMP_STATE";
 /** The footer status key. */
 const STATUS_KEY = "anon";
@@ -26,17 +26,29 @@ const SERVED_APIS = {
 	"openai-completions": true,
 	"openai-responses": true
 };
-const USAGE = "usage: /anon on|off|status";
+/** `/anon on --global` / `/anon off --global` also save the default that new omp sessions start with. */
+const GLOBAL_FLAG = "--global";
+const USAGE = "usage: /anon on|off [--global] | status";
 const VERBS = [
 	{
 		value: "on",
 		label: "on",
-		description: "route every provider through the transform proxy"
+		description: "route this session through the transform proxy"
+	},
+	{
+		value: "on --global",
+		label: "on --global",
+		description: "on, and the default for new sessions"
 	},
 	{
 		value: "off",
 		label: "off",
-		description: "restore the original provider base URLs"
+		description: "restore this session's original provider base URLs"
+	},
+	{
+		value: "off --global",
+		label: "off --global",
+		description: "off, and the default for new sessions"
 	},
 	{
 		value: "status",
@@ -44,6 +56,23 @@ const VERBS = [
 		description: "show the proxy, pipeline and routed providers"
 	}
 ];
+/** A parsed `/anon` argument; `undefined` for anything else. */
+function parseCommand(args) {
+	const [verb = "", ...flags] = args.trim().toLowerCase().split(/\s+/);
+	if (verb === "" || verb === "status") return flags.length === 0 ? {
+		verb: "status",
+		global: false
+	} : void 0;
+	if (verb !== "on" && verb !== "off") return void 0;
+	if (flags.length === 0) return {
+		verb,
+		global: false
+	};
+	return flags.length === 1 && flags[0] === GLOBAL_FLAG ? {
+		verb,
+		global: true
+	} : void 0;
+}
 /**
 * The process-wide `/anon` state machine. omp builds one extension instance per session
 * (subagents included) while they share one model registry, so one controller serves them all.
@@ -62,6 +91,12 @@ function createAnonController(deps) {
 	const registries = /* @__PURE__ */ new WeakMap();
 	let wanted = required;
 	let enabled = false;
+	/** The last successful `/anon on|off` in this omp process; once set, the saved default no longer applies here. */
+	let local;
+	/** Whether this controller holds the image block; only then does it release it. */
+	let imagesBlocked = false;
+	/** The host answered that it cannot block images; asked once, warned once. */
+	let imagesUnsupported = false;
 	let endpoint;
 	let starting;
 	let sessionId;
@@ -265,6 +300,24 @@ function createAnonController(deps) {
 	function stateLabel() {
 		return enabled ? "on" : wanted ? "error" : "off";
 	}
+	/** Follows `wanted`: images are blocked while model requests must go through the proxy. */
+	async function syncImages(ctx) {
+		const images = deps.images;
+		if (images === void 0 || imagesUnsupported || imagesBlocked === wanted) return;
+		let done;
+		try {
+			done = await images.setBlocked(wanted);
+		} catch (err) {
+			ctx.ui.notify(`anon: could not ${wanted ? "stop" : "restore"} image sending: ${errorMessage(err)}`, "warning");
+			return;
+		}
+		if (done) {
+			imagesBlocked = wanted;
+			return;
+		}
+		imagesUnsupported = true;
+		if (wanted) ctx.ui.notify("anon: this omp cannot stop image sending; the proxy refuses every request that carries an image", "warning");
+	}
 	/**
 	* Compact status for omp's main status line. omp strips ANSI colour from extension statuses and
 	* paints them in its accent colour, so the colour comes from an emoji: green on, red off, orange error.
@@ -282,6 +335,7 @@ function createAnonController(deps) {
 			lines.push(`pipeline: ${endpoint.pipeline ?? "the proxy default"}`);
 		}
 		if (sessionId !== void 0) lines.push(`session: ${sessionId}`);
+		if (imagesBlocked) lines.push("images: not sent (omp images.blockImages)");
 		const routed = [...state.routed.keys()].sort();
 		const refused = routed.flatMap((provider) => {
 			const reason = refusalReason(apis.get(provider), state.originals.get(provider));
@@ -300,7 +354,7 @@ function createAnonController(deps) {
 	*/
 	async function start(ctx, session, root) {
 		enterSession(ctx, root);
-		if (!wanted && readEnabled(statePath)) wanted = true;
+		if (!wanted && local === void 0 && readEnabled(statePath)) wanted = true;
 		if (wanted) {
 			const failure = await activate(ctx, session);
 			if (failure !== void 0) {
@@ -308,21 +362,25 @@ function createAnonController(deps) {
 				ctx.ui.notify(refusalHint(), "error");
 			}
 		}
+		await syncImages(ctx);
 		showStatus(ctx);
 	}
 	return {
 		required,
 		statePath,
 		async command(args, ctx, session) {
-			switch (args.trim().toLowerCase()) {
+			const parsed = parseCommand(args);
+			const scope = parsed?.global === true ? `this session; default for new sessions: ${parsed.verb}` : "this session";
+			switch (parsed?.verb) {
 				case "on": {
 					const before = wanted;
 					wanted = true;
 					const failure = await activate(ctx, session);
 					if (failure === void 0) {
-						persist(ctx, true);
+						local = true;
+						if (parsed.global) persist(ctx, true);
 						const count = stateOf(ctx.modelRegistry).routed.size;
-						ctx.ui.notify(`anon on: ${count} provider(s) routed through ${endpoint?.url}`, "info");
+						ctx.ui.notify(`anon on (${scope}): ${count} provider(s) routed through ${endpoint?.url}`, "info");
 						break;
 					}
 					wanted = before || required;
@@ -338,18 +396,19 @@ function createAnonController(deps) {
 					const lost = unroute(ctx);
 					wanted = false;
 					enabled = false;
+					local = false;
 					if (!await rebind(ctx, session)) ctx.ui.notify(`anon: could not rebind the active model ${ctx.model?.provider}/${ctx.model?.id}; select it again`, "warning");
-					persist(ctx, false);
-					ctx.ui.notify("anon off: original provider base URLs restored", "info");
+					if (parsed.global) persist(ctx, false);
+					ctx.ui.notify(`anon off (${scope}): original provider base URLs restored`, "info");
 					if (lost.length > 0) ctx.ui.notify(`anon: ${lost.join(", ")} lost their runtime registration (registered by another extension); restart omp to restore them`, "warning");
 					break;
 				}
-				case "":
 				case "status":
 					ctx.ui.notify(statusText(ctx), "info");
 					break;
 				default: ctx.ui.notify(USAGE, "error");
 			}
+			await syncImages(ctx);
 			showStatus(ctx);
 		},
 		completions(prefix) {
@@ -545,6 +604,7 @@ function originOf(url) {
 // src/omp/index.ts
 /** omp re-imports the extension per session; the controller (proxy child, recorded originals) is process-wide. */
 const CONTROLLER_KEY = Symbol.for("@skaile/transform-proxy/omp");
+const BLOCK_IMAGES = "images.blockImages";
 /** Registers the `/anon` command and the event handlers on one session's extension API. */
 function registerAnonExtension(pi, controller) {
 	pi.registerCommand("anon", {
@@ -562,9 +622,35 @@ function anonExtension(pi) {
 	const scope = globalThis;
 	registerAnonExtension(pi, scope[CONTROLLER_KEY] ??= createAnonController({
 		env: process.env,
-		home: homedir()
+		home: homedir(),
+		images: ompImageSending(pi)
 	}));
 }
+/** Blocks images through a runtime override of omp's `images.blockImages`, which strips them from every request, history included. */
+function ompImageSending(pi, load = loadOmpSettingsRegistry) {
+	let handle;
+	return { async setBlocked(blocked) {
+		const settings = pi.pi?.settings;
+		if (settings === void 0) return false;
+		handle ??= load().then(blockImagesHandle, () => void 0);
+		const resolved = await handle;
+		if (resolved === void 0) return false;
+		if (blocked) resolved.override(settings, true);
+		else resolved.clearOverride(settings);
+		return true;
+	} };
+}
+function loadOmpSettingsRegistry() {
+	return import("@oh-my-pi/pi-coding-agent/config/registry");
+}
+function blockImagesHandle(registry) {
+	if (typeof registry !== "object" || registry === null || !("lookup" in registry) || typeof registry.lookup !== "function") return void 0;
+	const handle = registry.lookup(BLOCK_IMAGES);
+	if (typeof handle !== "object" || handle === null) return void 0;
+	if (!("override" in handle) || typeof handle.override !== "function") return void 0;
+	if (!("clearOverride" in handle) || typeof handle.clearOverride !== "function") return void 0;
+	return handle;
+}
 function on(pi, event, run) {
 	pi.on(event, (_event, ctx) => guarded(ctx, () => run(ctx)));
 }
@@ -575,4 +661,4 @@ async function guarded(ctx, run) {
 		ctx.ui.notify(`anon: ${errorMessage(err)}`, "error");
 	}
 }
-export { createAnonController, anonExtension as default, defaultStatePath, registerAnonExtension };
+export { createAnonController, anonExtension as default, defaultStatePath, ompImageSending, registerAnonExtension };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skaile/transform-proxy",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "type": "module",
   "description": "Same-protocol passthrough proxy that runs model requests and replies through a chain of text transforms (Anthropic Messages, OpenAI chat, OpenAI responses)",
   "license": "MIT",