@raquezha/noheadroom 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @raquezha/noheadroom
+
+## 0.0.2
+
+### Patch Changes
+
+- 0d65b37: Initial release of the Headroom compression bridge for Pi.

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+This package is derived from @ryan_nookpi/pi-extension-headroom by Ryan/Jonghakseo, MIT licensed.
+
+Copyright for original portions belongs to the original authors.
+Modifications are copyright raquezha.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# noheadroom 🗜
+
+> **Reclaim your Pi context window.** A local-first context compression bridge for the Pi Coding Agent, powered by [Headroom](https://github.com/headroom-ai/headroom).
+
+`noheadroom` sits between Pi and your LLM, shrinking massive tool results and logs before they reach the model. Save tokens, keep more history, and prevent context-overflow in long sessions.
+
+## 🚀 Why noheadroom?
+
+Upstream Headroom protects common agent tool names like `read` and `bash` by default. In a standard Pi workflow, this means large file reads often bypass compression entirely.
+
+`noheadroom` adapts the compression payload to bypass these exclusions while **fully preserving your Pi session metadata**.
+
+| Setup | Tool Name | Headroom Action | Savings |
+|---|---|---|---|
+| Vanilla | `read` | `excluded_tool` | 0% |
+| **noheadroom** | `read` | `smart_crusher` | **60-90%** |
+
+## ✨ Features
+
+- **Adaptive Payload Sanitization**: renames tool calls during compression to ensure Headroom actually shrinks them.
+- **Pi-Native Metadata Preservation**: original tool IDs and names are never modified in your real session.
+- **Deep Visibility**: compression results appear in your terminal, the Pi footer, and as persistent entries in your session history.
+- **Docker-First Architecture**: designed to work seamlessly with a local containerized backend.
+- **Local-First Privacy**: by default, context never leaves your machine.
+
+## 📦 Installation
+
+### Within the `nothing` Monorepo
+
+`noheadroom` is built-in. Start Pi with compression enabled:
+
+```bash
+pi --headroom
+# OR full tokenmaxxing:
+pi --tkmx
+```
+
+### Standalone (NPM)
+
+```bash
+pi install npm:@raquezha/noheadroom
+```
+
+## 🛠 Usage
+
+### Backend Setup
+
+`noheadroom` requires a Headroom proxy running on `127.0.0.1:8788`. Use the provided scripts in the `nothing` repo:
+
+```bash
+./scripts/headroom-up.sh      # Launch Docker backend
+./scripts/headroom-health.sh  # Verify connection
+```
+
+### Commands
+
+Inside Pi, use the `/headroom` command:
+
+- `/headroom` — Session statistics and status summary.
+- `/headroom on` | `off` — Toggle compression live.
+- `/headroom health` — Check if the backend is alive.
+- `/headroom stats` — Inspect raw backend metrics.
+
+## 🔧 Configuration
+
+Settings are stored in `~/.pi/agent/headroom/settings.json`:
+
+```json
+{
+  "enabled": true,
+  "baseUrl": "http://127.0.0.1:8788",
+  "autoStart": false,
+  "minContextTokens": 10000,
+  "minMessageChars": 2000
+}
+```
+
+- **`autoStart`**: Set to `false` when using the Docker backend.
+- **`minContextTokens`**: Compression kicks in once the context reaches this size.
+
+## 🛡 Privacy & Security
+
+Context is sent only to `localhost` (`127.0.0.1`) by default. Remote proxies are strictly blocked unless `PI_HEADROOM_ALLOW_REMOTE=1` is explicitly set in your environment.
+
+## 🤝 Attribution
+
+This project is a fork of [@ryan_nookpi/pi-extension-headroom](https://github.com/Jonghakseo/pi-extension/tree/main/packages/headroom) by [Ryan/Jonghakseo](https://github.com/Jonghakseo), modified to support Pi-specific tool-result adaptation. Licensed under MIT.
+
+---
+
+**[nothing](https://github.com/raquezha/nothing)** — Local-first agentic development setup.

package/UPSTREAM-README.md

@@ -0,0 +1,68 @@
+# @ryan_nookpi/pi-extension-headroom
+
+This extension reclaims context window in pi by compressing large tool results through a [Headroom](https://github.com/headroom-ai/headroom) proxy before each LLM call.
+
+Headroom runs locally, compresses only oversized `toolResult` payloads, and leaves your prompts, assistant turns, and tool-call metadata untouched. Compression is applied only when the proxy is online and the change passes strict alignment guards, so it never silently rewrites your conversation.
+
+## Install
+
+```bash
+pi install npm:@ryan_nookpi/pi-extension-headroom
+```
+
+You also need the Headroom proxy available on your machine:
+
+```bash
+pip install "headroom-ai[proxy]"
+```
+
+By default the extension auto-starts a local token-mode proxy (`headroom proxy --mode token --no-cache`) on `http://127.0.0.1:8788` and leaves it running after pi exits.
+
+## How it works
+
+- Listens on the `context` event fired before each LLM call.
+- Skips entirely until context usage reaches the configured token threshold.
+- Sends an OpenAI-shaped copy of the conversation to the proxy's `/v1/compress` endpoint.
+- Applies the result only to large `toolResult` messages, preserving pi metadata (`toolName`, `details`, tool-call ids, images).
+- Rejects any response that changes message count, roles, tool-call ids, or non-candidate content.
+
+## Privacy
+
+Compression sends conversation context to the proxy, so remote URLs are blocked by default. Only `localhost`/`127.0.0.1`/`::1` are allowed unless you explicitly set `PI_HEADROOM_ALLOW_REMOTE=1` for a proxy you trust.
+
+## Commands
+
+- `/headroom` — show current status and session stats.
+- `/headroom on` — enable compression and ensure the proxy is running.
+- `/headroom off` — disable compression for this session (the proxy keeps running).
+- `/headroom health` — check / start the proxy and report whether it is online.
+- `/headroom stats` — print the proxy's own `/stats` output.
+- `/headroom-health` — shortcut for `/headroom health`.
+
+The footer shows a compact status (`✓ Headroom -42% (12,345 saved)`) once compression is applied.
+
+## Configuration
+
+Settings are read at startup from `~/.pi/agent/headroom/settings.json`. Values in this file override environment variables; environment variables remain supported as fallbacks.
+
+Example:
+
+```json
+{
+  "minContextTokens": 10000,
+  "minMessageChars": 1000
+}
+```
+
+| Setting key | Env fallback | Default | Description |
+| --- | --- | --- | --- |
+| `enabled` | `PI_HEADROOM_ENABLED` | `true` | Enable compression on start. |
+| `baseUrl` (`url` also accepted) | `PI_HEADROOM_URL` (`HEADROOM_URL` / `HEADROOM_BASE_URL` also accepted) | `http://127.0.0.1:8788` | Proxy base URL. |
+| `allowRemote` | `PI_HEADROOM_ALLOW_REMOTE` | `false` | Allow non-local proxy URLs. |
+| `autoStart` | `PI_HEADROOM_AUTO_START` | `true` | Auto-start a local persistent proxy when offline. |
+| `command` | `PI_HEADROOM_COMMAND` | `headroom` | Command used to launch the proxy. |
+| `minContextTokens` | `PI_HEADROOM_MIN_CONTEXT_TOKENS` | `20000` | Skip compression below this context token count. |
+| `minMessageChars` | `PI_HEADROOM_MIN_MESSAGE_CHARS` | `2000` | Only compress tool results at or above this size. |
+| `timeoutMs` | `PI_HEADROOM_TIMEOUT_MS` | `30000` | HTTP timeout for proxy requests. |
+
+Boolean values accept JSON booleans, or strings such as `1/0`, `true/false`, `yes/no`, `on/off`.

package/dist/bridge.d.ts

@@ -0,0 +1,3 @@
+import type { AgentMessage, ApplyCompressionOptions, ApplyCompressionResult, CompressionMapping, CompressionPayload, OpenAIMessage } from "./types.js";
+export declare function buildCompressionPayload(messages: AgentMessage[], minMessageChars: number): CompressionPayload;
+export declare function applyCompressionResult(originalMessages: AgentMessage[], mappings: CompressionMapping[], compressedMessages: OpenAIMessage[], _options: ApplyCompressionOptions): ApplyCompressionResult;

package/dist/bridge.js

@@ -0,0 +1,202 @@
+const STANDARD_COMPRESSIBLE_ROLES = new Set(["user", "assistant", "toolResult"]);
+export function buildCompressionPayload(messages, minMessageChars) {
+    const mappings = [];
+    let candidateCount = 0;
+    for (let sourceIndex = 0; sourceIndex < messages.length; sourceIndex++) {
+        const source = messages[sourceIndex];
+        const converted = convertMessage(source);
+        if (!converted)
+            continue;
+        const originalText = extractOpenAIText(converted);
+        const applyTo = source.role === "toolResult" && originalText.length >= minMessageChars ? "toolResult" : null;
+        if (applyTo)
+            candidateCount++;
+        mappings.push({ sourceIndex, message: converted, applyTo, originalText });
+    }
+    return {
+        messages: mappings.map((mapping) => mapping.message),
+        mappings,
+        candidateCount,
+    };
+}
+export function applyCompressionResult(originalMessages, mappings, compressedMessages, _options) {
+    if (compressedMessages.length !== mappings.length) {
+        return { ok: false, reason: "message-count-changed" };
+    }
+    const nextMessages = structuredClone(originalMessages);
+    let appliedMessages = 0;
+    for (let index = 0; index < mappings.length; index++) {
+        const mapping = mappings[index];
+        const compressed = compressedMessages[index];
+        const validation = validateAlignedMessage(mapping.message, compressed);
+        if (!validation.ok)
+            return validation;
+        const nextText = extractOpenAIText(compressed);
+        if (nextText === mapping.originalText)
+            continue;
+        if (mapping.applyTo !== "toolResult") {
+            return { ok: false, reason: `non-candidate-changed:${mapping.message.role}` };
+        }
+        const target = nextMessages[mapping.sourceIndex];
+        if (target.role !== "toolResult") {
+            return { ok: false, reason: "source-role-mismatch" };
+        }
+        if (!replaceTextContent(target, nextText)) {
+            return { ok: false, reason: "target-content-unreplaceable" };
+        }
+        appliedMessages++;
+    }
+    if (appliedMessages === 0) {
+        return { ok: false, reason: "no-applicable-message-changed" };
+    }
+    return { ok: true, messages: nextMessages, appliedMessages };
+}
+function convertMessage(message) {
+    if (!message.role || !STANDARD_COMPRESSIBLE_ROLES.has(message.role))
+        return undefined;
+    switch (message.role) {
+        case "user":
+            return convertUserMessage(message);
+        case "assistant":
+            return convertAssistantMessage(message);
+        case "toolResult":
+            return convertToolResultMessage(message);
+        default:
+            return undefined;
+    }
+}
+function convertUserMessage(message) {
+    if (!hasContent(message))
+        return undefined;
+    if (typeof message.content === "string") {
+        return { role: "user", content: message.content };
+    }
+    if (!Array.isArray(message.content))
+        return undefined;
+    const text = message.content
+        .filter((part) => isTextContent(part))
+        .map((part) => part.text)
+        .join("\n");
+    if (text)
+        return { role: "user", content: text };
+    const hasImages = message.content.some((part) => isImageContent(part));
+    return hasImages ? { role: "user", content: "[image omitted from Headroom compression payload]" } : undefined;
+}
+function convertAssistantMessage(message) {
+    if (!hasContent(message) || !Array.isArray(message.content))
+        return undefined;
+    const text = message.content
+        .filter((part) => isTextContent(part))
+        .map((part) => part.text)
+        .join("");
+    const toolCalls = message.content.filter((part) => isToolCall(part));
+    if (!text && toolCalls.length === 0)
+        return undefined;
+    const converted = {
+        role: "assistant",
+        content: text || null,
+    };
+    if (toolCalls.length > 0) {
+        converted.tool_calls = toolCalls.map(convertToolCall);
+    }
+    return converted;
+}
+function convertToolResultMessage(message) {
+    if (!hasContent(message))
+        return undefined;
+    const toolCallId = readStringProperty(message, "toolCallId");
+    if (!toolCallId)
+        return undefined;
+    return {
+        role: "tool",
+        content: extractTextFromContent(message.content),
+        tool_call_id: toolCallId,
+    };
+}
+function convertToolCall(toolCall) {
+    return {
+        id: toolCall.id,
+        type: "function",
+        function: {
+            // Headroom may protect/exclude built-in agent tool names such as `read` and `bash`.
+            // This payload is only for compression alignment; Pi's original tool metadata is preserved
+            // in originalMessages and restored when applying the compressed toolResult text.
+            name: "pi_tool_result",
+            arguments: JSON.stringify({ originalToolName: toolCall.name }),
+        },
+    };
+}
+function validateAlignedMessage(original, compressed) {
+    if (original.role !== compressed.role) {
+        return { ok: false, reason: `role-changed:${original.role}->${compressed.role}` };
+    }
+    if (original.role === "tool" && compressed.role === "tool") {
+        if (original.tool_call_id !== compressed.tool_call_id)
+            return { ok: false, reason: "tool-call-id-changed" };
+    }
+    if (original.role === "assistant" && compressed.role === "assistant") {
+        const originalIds = (original.tool_calls ?? []).map((call) => call.id).join("\n");
+        const compressedIds = (compressed.tool_calls ?? []).map((call) => call.id).join("\n");
+        if (originalIds !== compressedIds)
+            return { ok: false, reason: "assistant-tool-calls-changed" };
+    }
+    return { ok: true };
+}
+function extractOpenAIText(message) {
+    if (message.role === "assistant")
+        return typeof message.content === "string" ? message.content : "";
+    if (message.role === "tool" || message.role === "system")
+        return message.content;
+    if (typeof message.content === "string")
+        return message.content;
+    return message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n");
+}
+function extractTextFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => isTextContent(part))
+        .map((part) => part.text)
+        .join("\n");
+}
+function replaceTextContent(message, text) {
+    if (typeof message.content === "string") {
+        message.content = text;
+        return true;
+    }
+    if (!Array.isArray(message.content))
+        return false;
+    const imageParts = message.content.filter((part) => isImageContent(part));
+    message.content = [{ type: "text", text }, ...imageParts];
+    return true;
+}
+function hasContent(message) {
+    return "content" in message;
+}
+function isTextContent(value) {
+    return isRecord(value) && value.type === "text" && typeof value.text === "string";
+}
+function isImageContent(value) {
+    return (isRecord(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string");
+}
+function isToolCall(value) {
+    return (isRecord(value) &&
+        value.type === "toolCall" &&
+        typeof value.id === "string" &&
+        typeof value.name === "string" &&
+        isRecord(value.arguments));
+}
+function readStringProperty(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const property = value[key];
+    return typeof property === "string" ? property : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import type { CompressResult, OpenAIMessage } from "./types.js";
+interface HeadroomClientOptions {
+    baseUrl: string;
+    timeoutMs: number;
+}
+export declare class HeadroomHttpClient {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    constructor(options: HeadroomClientOptions);
+    health(signal?: AbortSignal): Promise<boolean>;
+    stats(signal?: AbortSignal): Promise<unknown>;
+    compress(messages: OpenAIMessage[], model: string | undefined, signal?: AbortSignal): Promise<CompressResult>;
+}
+export {};

package/dist/client.js

@@ -0,0 +1,95 @@
+export class HeadroomHttpClient {
+    baseUrl;
+    timeoutMs;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this.timeoutMs = options.timeoutMs;
+    }
+    async health(signal) {
+        try {
+            const response = await fetch(`${this.baseUrl}/health`, {
+                signal: buildSignal(this.timeoutMs, signal),
+            });
+            if (!response.ok)
+                return false;
+            const body = await readJsonObject(response);
+            if (!body)
+                return true;
+            return body.status === "healthy" || body.status === "ok" || "optimize" in body || "stats" in body;
+        }
+        catch {
+            return false;
+        }
+    }
+    async stats(signal) {
+        const response = await fetch(`${this.baseUrl}/stats`, {
+            signal: buildSignal(this.timeoutMs, signal),
+        });
+        if (!response.ok) {
+            throw new Error(`Headroom /stats failed with HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    async compress(messages, model, signal) {
+        const response = await fetch(`${this.baseUrl}/v1/compress`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Headroom-Stack": "pi-extension",
+            },
+            body: JSON.stringify({ messages, model: model || "gpt-4o" }),
+            signal: buildSignal(this.timeoutMs, signal),
+        });
+        if (!response.ok) {
+            const message = await readErrorMessage(response);
+            throw new Error(message || `Headroom /v1/compress failed with HTTP ${response.status}`);
+        }
+        const payload = (await response.json());
+        return {
+            messages: payload.messages,
+            tokensBefore: payload.tokens_before,
+            tokensAfter: payload.tokens_after,
+            tokensSaved: payload.tokens_saved,
+            compressionRatio: payload.compression_ratio,
+            transformsApplied: payload.transforms_applied ?? [],
+            ccrHashes: payload.ccr_hashes ?? [],
+            compressed: true,
+        };
+    }
+}
+async function readJsonObject(response) {
+    try {
+        const body = (await response.json());
+        return isRecord(body) ? body : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readErrorMessage(response) {
+    try {
+        const body = (await response.json());
+        if (!isRecord(body))
+            return undefined;
+        const error = body.error;
+        if (isRecord(error) && typeof error.message === "string")
+            return error.message;
+        if (typeof body.message === "string")
+            return body.message;
+    }
+    catch {
+        // Ignore malformed error bodies.
+    }
+    return undefined;
+}
+function buildSignal(timeoutMs, signal) {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    if (!signal)
+        return timeoutSignal;
+    if (signal.aborted)
+        return signal;
+    return AbortSignal.any([signal, timeoutSignal]);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/config.d.ts

@@ -0,0 +1,18 @@
+import type { HeadroomConfig } from "./types.js";
+export declare const HEADROOM_SETTINGS_DIR: string;
+export declare const HEADROOM_SETTINGS_FILE: string;
+export interface HeadroomSettings {
+    enabled?: boolean | string;
+    baseUrl?: string;
+    url?: string;
+    allowRemote?: boolean | string;
+    autoStart?: boolean | string;
+    command?: string;
+    minContextTokens?: number | string;
+    minMessageChars?: number | string;
+    timeoutMs?: number | string;
+}
+export declare function loadHeadroomSettings(settingsPath?: string): HeadroomSettings;
+export declare function loadHeadroomConfig(env?: NodeJS.ProcessEnv, settings?: HeadroomSettings): HeadroomConfig;
+export declare function isLocalHeadroomUrl(rawUrl: string): boolean;
+export declare function isRemoteBlocked(config: Pick<HeadroomConfig, "baseUrl" | "allowRemote">): boolean;

package/dist/config.js

@@ -0,0 +1,78 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const DEFAULT_BASE_URL = "http://127.0.0.1:8788";
+const DEFAULT_MIN_CONTEXT_TOKENS = 20_000;
+const DEFAULT_MIN_MESSAGE_CHARS = 2_000;
+const DEFAULT_TIMEOUT_MS = 30_000;
+export const HEADROOM_SETTINGS_DIR = path.join(os.homedir(), ".pi", "agent", "headroom");
+export const HEADROOM_SETTINGS_FILE = path.join(HEADROOM_SETTINGS_DIR, "settings.json");
+export function loadHeadroomSettings(settingsPath = HEADROOM_SETTINGS_FILE) {
+    try {
+        const raw = fs.readFileSync(settingsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // Missing or invalid settings.json falls back to env/defaults.
+    }
+    return {};
+}
+export function loadHeadroomConfig(env = process.env, settings = env === process.env ? loadHeadroomSettings() : {}) {
+    const envBaseUrl = env.PI_HEADROOM_URL || env.HEADROOM_URL || env.HEADROOM_BASE_URL || DEFAULT_BASE_URL;
+    const baseUrl = normalizeBaseUrl(parseString(settings.baseUrl ?? settings.url, envBaseUrl));
+    return {
+        enabled: parseBoolean(settings.enabled, parseBoolean(env.PI_HEADROOM_ENABLED, true)),
+        baseUrl,
+        allowRemote: parseBoolean(settings.allowRemote, parseBoolean(env.PI_HEADROOM_ALLOW_REMOTE, false)),
+        autoStart: parseBoolean(settings.autoStart, parseBoolean(env.PI_HEADROOM_AUTO_START, true)),
+        command: parseString(settings.command, env.PI_HEADROOM_COMMAND?.trim() || "headroom"),
+        minContextTokens: parseInteger(settings.minContextTokens, parseInteger(env.PI_HEADROOM_MIN_CONTEXT_TOKENS, DEFAULT_MIN_CONTEXT_TOKENS, 0), 0),
+        minMessageChars: parseInteger(settings.minMessageChars, parseInteger(env.PI_HEADROOM_MIN_MESSAGE_CHARS, DEFAULT_MIN_MESSAGE_CHARS, 1), 1),
+        timeoutMs: parseInteger(settings.timeoutMs, parseInteger(env.PI_HEADROOM_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, 100), 100),
+    };
+}
+export function isLocalHeadroomUrl(rawUrl) {
+    try {
+        const url = new URL(rawUrl);
+        return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(url.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+export function isRemoteBlocked(config) {
+    return !config.allowRemote && !isLocalHeadroomUrl(config.baseUrl);
+}
+function normalizeBaseUrl(raw) {
+    const trimmed = raw.trim() || DEFAULT_BASE_URL;
+    return trimmed.replace(/\/+$/, "");
+}
+function parseString(raw, fallback) {
+    if (typeof raw !== "string")
+        return fallback;
+    return raw.trim() || fallback;
+}
+function parseBoolean(raw, fallback) {
+    if (raw === undefined)
+        return fallback;
+    if (typeof raw === "boolean")
+        return raw;
+    if (typeof raw !== "string")
+        return fallback;
+    const normalized = raw.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+        return false;
+    return fallback;
+}
+function parseInteger(raw, fallback, min) {
+    if (raw === undefined)
+        return fallback;
+    const parsed = typeof raw === "number" ? raw : typeof raw === "string" ? Number.parseInt(raw, 10) : Number.NaN;
+    if (!Number.isFinite(parsed) || parsed < min)
+        return fallback;
+    return Math.trunc(parsed);
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { HeadroomConfig, HeadroomStats } from "./types.js";
+interface HeadroomRuntimeState {
+    enabled: boolean;
+    proxyOnline: boolean | null;
+    proxyStarting: boolean;
+    proxyStartAttempted: boolean;
+    remoteWarningShown: boolean;
+    offlineWarningShown: boolean;
+    stats: HeadroomStats;
+}
+export default function headroomExtension(pi: ExtensionAPI): void;
+declare function isAbortOrTimeoutError(error: unknown): boolean;
+declare function renderFooterStatus(ctx: ExtensionContext, config: HeadroomConfig, state: HeadroomRuntimeState): string;
+export declare const __test__: {
+    isAbortOrTimeoutError: typeof isAbortOrTimeoutError;
+    renderFooterStatus: typeof renderFooterStatus;
+};
+export {};