@skaile/transform-proxy 0.2.4 → 0.2.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 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.
+
 ## 0.2.4
 
 - omp extension: the status is one glyph instead of a word: `A` (on), `Ⱥ` (crossed A, off), `A!` (error; was `anon on`, `anon off`, `anon error`). It fits omp's `status` status-line segment; the README shows the `statusLine` config that puts it into the main line.

package/README.md

@@ -93,9 +93,9 @@ 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 one-glyph status: `A` (on), `Ⱥ` (crossed A, off) or `A!` (error). 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|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 glyph 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):
+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):
 
 ```yaml
 statusLine:
@@ -110,11 +110,12 @@ statusLine:
   - Otherwise it starts one proxy per omp process as a child process: the system Node (`SKAILE_TRANSFORM_PROXY_NODE`, else `node` from `PATH`) runs this package's CLI with the config lookup of the CLI (`./.skaile/transform-proxy.yaml`, then `~/.config/skaile/transform-proxy.yaml`), `--port 0 --host 127.0.0.1 --exit-with-stdin` and a random token in `SKAILE_TRANSFORM_PROXY_TOKEN`, which every routed provider sends. That config must set `defaultPipeline`. Without a config, `/anon on` refuses and says where to put one. A child that exits before printing `listening <url>`, or stays silent for 60 s, fails `/anon on` with its last stderr lines.
   - omp is a compiled Bun executable, and its resolver cannot load transform modules with native or ML dependencies (`onnxruntime-node`, `@huggingface/transformers`, `ibantools`) from `node_modules`; Node can. The child exits with omp: its stdin pipe closes when omp exits (SIGKILL included), and omp kills it on a normal exit. It does not keep omp's event loop alive. A child that dies later is replaced on the next turn.
   - 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!`.
+  - 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.
+- `/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.
 - 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.
 - `SKAILE_TRANSFORM_PROXY_MODE=required` (set by a skaile session in required mode) turns routing on at session start and refuses `/anon off`.
 

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;
@@ -124,7 +138,7 @@ interface AnonController {
  *
  * `wanted`: model requests must go through the proxy (required mode, or `/anon on`).
  * `enabled`: every provider is routed and the active model is rebound. `wanted` without
- * `enabled` is the error state: the status shows `A!` and `providerRequest` refuses
+ * `enabled` is the error state: the status shows `🟠A` and `providerRequest` refuses
  * every request that would bypass the proxy.
  */
 export declare function createAnonController(deps: AnonControllerDeps): AnonController;
@@ -133,4 +147,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

@@ -50,7 +50,7 @@ const VERBS = [
 *
 * `wanted`: model requests must go through the proxy (required mode, or `/anon on`).
 * `enabled`: every provider is routed and the active model is rebound. `wanted` without
-* `enabled` is the error state: the status shows `A!` and `providerRequest` refuses
+* `enabled` is the error state: the status shows `🟠A` and `providerRequest` refuses
 * every request that would bypass the proxy.
 */
 function createAnonController(deps) {
@@ -62,6 +62,10 @@ function createAnonController(deps) {
 	const registries = /* @__PURE__ */ new WeakMap();
 	let wanted = required;
 	let enabled = false;
+	/** 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,9 +269,30 @@ function createAnonController(deps) {
 	function stateLabel() {
 		return enabled ? "on" : wanted ? "error" : "off";
 	}
-	/** One glyph per state, so the status fits into omp's main status line: `A` on, `Ⱥ` (crossed A) off, `A!` error. */
+	/** 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.
+	*/
 	function showStatus(ctx) {
-		ctx.ui.setStatus(STATUS_KEY, enabled ? "A" : wanted ? "A!" : "Ⱥ");
+		ctx.ui.setStatus(STATUS_KEY, enabled ? "🟢A" : wanted ? "🟠A" : "🔴A");
 	}
 	function statusText(ctx) {
 		const registry = ctx.modelRegistry;
@@ -279,6 +304,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));
@@ -305,6 +331,7 @@ function createAnonController(deps) {
 				ctx.ui.notify(refusalHint(), "error");
 			}
 		}
+		await syncImages(ctx);
 		showStatus(ctx);
 	}
 	return {
@@ -347,6 +374,7 @@ function createAnonController(deps) {
 					break;
 				default: ctx.ui.notify(USAGE, "error");
 			}
+			await syncImages(ctx);
 			showStatus(ctx);
 		},
 		completions(prefix) {
@@ -542,6 +570,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", {
@@ -559,9 +588,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)));
 }
@@ -572,4 +627,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.4",
+  "version": "0.2.6",
   "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",