@casualjim/pi-headroom 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,176 @@
1
+ import * as fs from "node:fs";
2
+ import * as os from "node:os";
3
+ import * as path from "node:path";
4
+ import type { HeadroomConfig, HeadroomMode } from "./types.js";
5
+
6
+ const DEFAULT_BASE_URL = "http://127.0.0.1:8787"; // Headroom's own default port; custom ports come from settings/env.
7
+ const DEFAULT_MIN_CONTEXT_TOKENS = 20_000;
8
+ const DEFAULT_MIN_MESSAGE_CHARS = 2_000;
9
+ const DEFAULT_TIMEOUT_MS = 20_000;
10
+ // Must stay under omp's per-event extension handler cap (30s, runner.ts
11
+ // EXTENSION_HANDLER_TIMEOUT_MS): the compress call runs inside the `context`
12
+ // handler, and omp kills the handler at the cap before we can return. pi has no
13
+ // such cap, so the tighter budget is safe for both hosts.
14
+
15
+ export const HEADROOM_SETTINGS_DIR = path.join(os.homedir(), ".pi", "agent", "headroom");
16
+ export const HEADROOM_SETTINGS_FILE = path.join(HEADROOM_SETTINGS_DIR, "settings.json");
17
+
18
+ /** Host runtime this extension is loaded into. */
19
+ export type HeadroomHost = "omp" | "pi";
20
+
21
+ /**
22
+ * omp's ExtensionAPI exposes `zod`; pi's does not. Both hosts load this same
23
+ * file, so host detection decides settings location only.
24
+ */
25
+ export function detectHeadroomHost(api: unknown): HeadroomHost {
26
+ return api && typeof (api as { zod?: unknown }).zod !== "undefined" ? "omp" : "pi";
27
+ }
28
+
29
+ function expandHome(raw: string): string {
30
+ return raw.replace(/^~(?=\/|$)/, os.homedir());
31
+ }
32
+
33
+ /**
34
+ * Resolve the settings file for a host.
35
+ * `PI_HEADROOM_SETTINGS` (exact file) → `PI_CODING_AGENT_DIR` (omp + pi honour it)
36
+ * → host agent dir (`~/.omp/agent` for omp, `~/.pi/agent` for pi).
37
+ */
38
+ export function resolveHeadroomSettingsFile(host: HeadroomHost, env: NodeJS.ProcessEnv = process.env): string {
39
+ const explicit = env.PI_HEADROOM_SETTINGS?.trim();
40
+ if (explicit) return path.resolve(expandHome(explicit));
41
+
42
+ const agentDir = env.PI_CODING_AGENT_DIR?.trim();
43
+ if (agentDir) return path.join(expandHome(agentDir), "headroom", "settings.json");
44
+
45
+ const agentRoot = host === "omp" ? path.join(os.homedir(), ".omp", "agent") : path.join(os.homedir(), ".pi", "agent");
46
+ return path.join(agentRoot, "headroom", "settings.json");
47
+ }
48
+
49
+ export interface HeadroomSettings {
50
+ enabled?: boolean | string;
51
+ baseUrl?: string;
52
+ url?: string;
53
+ allowRemote?: boolean | string;
54
+ mode?: string;
55
+ silent?: boolean | string;
56
+ renameToolCalls?: boolean | string;
57
+ minContextTokens?: number | string;
58
+ minMessageChars?: number | string;
59
+ timeoutMs?: number | string;
60
+ }
61
+
62
+ export function loadHeadroomSettings(settingsPath: string = HEADROOM_SETTINGS_FILE): HeadroomSettings {
63
+ try {
64
+ const raw = fs.readFileSync(settingsPath, "utf-8");
65
+ const parsed = JSON.parse(raw) as unknown;
66
+ if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as HeadroomSettings;
67
+ } catch {
68
+ // Missing or invalid settings.json falls back to env/defaults.
69
+ }
70
+ return {};
71
+ }
72
+
73
+ export function saveHeadroomSettings(
74
+ patch: Partial<HeadroomSettings>,
75
+ settingsPath: string = HEADROOM_SETTINGS_FILE,
76
+ ): void {
77
+ const current = loadHeadroomSettings(settingsPath);
78
+ const updated = { ...current, ...patch };
79
+ try {
80
+ fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
81
+ fs.writeFileSync(settingsPath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
82
+ } catch (error) {
83
+ console.warn(`[pi-headroom] Failed to save settings to ${settingsPath}:`, error);
84
+ }
85
+ }
86
+
87
+ export function loadHeadroomConfig(
88
+ env: NodeJS.ProcessEnv = process.env,
89
+ settings?: HeadroomSettings,
90
+ host: HeadroomHost = "pi",
91
+ ): HeadroomConfig {
92
+ const resolvedSettings =
93
+ settings ?? (env === process.env ? loadHeadroomSettings(resolveHeadroomSettingsFile(host, env)) : {});
94
+ const envBaseUrl = env.PI_HEADROOM_URL || env.HEADROOM_URL || env.HEADROOM_BASE_URL || DEFAULT_BASE_URL;
95
+ const baseUrl = normalizeBaseUrl(parseString(resolvedSettings.baseUrl ?? resolvedSettings.url, envBaseUrl));
96
+ return {
97
+ enabled: parseBoolean(resolvedSettings.enabled, parseBoolean(env.PI_HEADROOM_ENABLED, true)),
98
+ baseUrl,
99
+ allowRemote: parseBoolean(resolvedSettings.allowRemote, parseBoolean(env.PI_HEADROOM_ALLOW_REMOTE, false)),
100
+ renameToolCalls: parseBoolean(
101
+ resolvedSettings.renameToolCalls,
102
+ parseBoolean(env.PI_HEADROOM_RENAME_TOOL_CALLS, true),
103
+ ),
104
+ mode: parseMode(
105
+ resolvedSettings.mode,
106
+ env.PI_HEADROOM_MODE,
107
+ parseBoolean(resolvedSettings.silent, parseBoolean(env.PI_HEADROOM_SILENT, false)) ? "silent" : "normal",
108
+ ),
109
+ minContextTokens: parseInteger(
110
+ resolvedSettings.minContextTokens,
111
+ parseInteger(env.PI_HEADROOM_MIN_CONTEXT_TOKENS, DEFAULT_MIN_CONTEXT_TOKENS, 0),
112
+ 0,
113
+ ),
114
+ minMessageChars: parseInteger(
115
+ resolvedSettings.minMessageChars,
116
+ parseInteger(env.PI_HEADROOM_MIN_MESSAGE_CHARS, DEFAULT_MIN_MESSAGE_CHARS, 1),
117
+ 1,
118
+ ),
119
+ timeoutMs: parseInteger(
120
+ resolvedSettings.timeoutMs,
121
+ parseInteger(env.PI_HEADROOM_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, 100),
122
+ 100,
123
+ ),
124
+ };
125
+ }
126
+
127
+ export function isLocalHeadroomUrl(rawUrl: string): boolean {
128
+ try {
129
+ const url = new URL(rawUrl);
130
+ return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(url.hostname);
131
+ } catch {
132
+ return false;
133
+ }
134
+ }
135
+
136
+ export function isRemoteBlocked(config: Pick<HeadroomConfig, "baseUrl" | "allowRemote">): boolean {
137
+ return !config.allowRemote && !isLocalHeadroomUrl(config.baseUrl);
138
+ }
139
+
140
+ function normalizeBaseUrl(raw: string): string {
141
+ const trimmed = raw.trim() || DEFAULT_BASE_URL;
142
+ return trimmed.replace(/\/+$/, "");
143
+ }
144
+
145
+ function parseString(raw: unknown, fallback: string): string {
146
+ if (typeof raw !== "string") return fallback;
147
+ return raw.trim() || fallback;
148
+ }
149
+
150
+ function parseBoolean(raw: unknown, fallback: boolean): boolean {
151
+ if (raw === undefined) return fallback;
152
+ if (typeof raw === "boolean") return raw;
153
+ if (typeof raw !== "string") return fallback;
154
+ const normalized = raw.trim().toLowerCase();
155
+ if (["1", "true", "yes", "on"].includes(normalized)) return true;
156
+ if (["0", "false", "no", "off"].includes(normalized)) return false;
157
+ return fallback;
158
+ }
159
+
160
+ function parseInteger(raw: unknown, fallback: number, min: number): number {
161
+ if (raw === undefined) return fallback;
162
+ const parsed = typeof raw === "number" ? raw : typeof raw === "string" ? Number.parseInt(raw, 10) : Number.NaN;
163
+ if (!Number.isFinite(parsed) || parsed < min) return fallback;
164
+ return Math.trunc(parsed);
165
+ }
166
+
167
+ const HEADROOM_MODES: HeadroomMode[] = ["normal", "quiet", "silent"];
168
+
169
+ function parseMode(raw: unknown, envRaw: string | undefined, fallback: HeadroomMode): HeadroomMode {
170
+ const normalize = (v: unknown): HeadroomMode | null => {
171
+ if (typeof v !== "string") return null;
172
+ const s = v.trim().toLowerCase() as HeadroomMode;
173
+ return HEADROOM_MODES.includes(s) ? s : null;
174
+ };
175
+ return normalize(raw) ?? normalize(envRaw) ?? fallback;
176
+ }