pi-harness-runtime 0.10.43 → 1.1.1

package/packages/context-discovery/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@pi/context-discovery",
+  "version": "0.10.30",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/packages/context-manager/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi-harness/context-manager",
+  "version": "0.10.30",
+  "description": "Context Window Manager — prevents model context overflow via compaction and resume prompts (RFC-0010)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0"
+  }
+}

package/packages/context-manager/test/context.test.ts

@@ -0,0 +1,198 @@
+/**
+ * Context Manager Tests (RFC-0010)
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	DEFAULT_POLICY,
+	estimatePressure,
+	getPressureLevel,
+	createSessionScope,
+	setTTL,
+	addToScope,
+	evictExpired,
+	prioritize,
+	estimateTokens,
+	calculateTotalTokens,
+	compactContext,
+	generateResumePrompt,
+	formatResumeMarkdown,
+} from "../src/index.js";
+
+const makeItem = (
+	overrides?: Partial<import("../src/index.js").ContextItem>,
+): import("../src/index.js").ContextItem => ({
+	id: `item-${Math.random().toString(36).slice(2)}`,
+	role: "user",
+	content: "Test content",
+	tokens: 10,
+	priority: 5,
+	timestamp: Date.now(),
+	...overrides,
+});
+
+describe("DEFAULT_POLICY", () => {
+	it("has threshold values", () => {
+		expect(DEFAULT_POLICY.warningThreshold).toBe(0.6);
+		expect(DEFAULT_POLICY.compactThreshold).toBe(0.7);
+		expect(DEFAULT_POLICY.hardStopThreshold).toBe(0.85);
+	});
+});
+
+describe("estimatePressure", () => {
+	it("returns ratio", () => expect(estimatePressure(5000, 10000)).toBe(0.5));
+	it("caps at 1", () => expect(estimatePressure(15000, 10000)).toBe(1));
+	it("handles zero max", () => expect(estimatePressure(100, 0)).toBe(1));
+});
+
+describe("getPressureLevel", () => {
+	it("normal below warning", () =>
+		expect(getPressureLevel(0.3)).toBe("normal"));
+	it("warning above warningThreshold", () =>
+		expect(getPressureLevel(0.65)).toBe("warning"));
+	it("compact above compactThreshold", () =>
+		expect(getPressureLevel(0.75)).toBe("compact"));
+	it("hard_stop above hardStopThreshold", () =>
+		expect(getPressureLevel(0.9)).toBe("hard_stop"));
+	it("uses custom policy", () => {
+		const custom = {
+			warningThreshold: 0.1,
+			compactThreshold: 0.2,
+			hardStopThreshold: 0.3,
+		};
+		expect(getPressureLevel(0.25, custom)).toBe("compact");
+	});
+});
+
+describe("createSessionScope", () => {
+	it("creates with defaults", () => {
+		const scope = createSessionScope("session-1");
+		expect(scope.id).toBe("session-1");
+		expect(scope.items).toEqual([]);
+		expect(scope.ttlMs).toBe(30 * 60 * 1000);
+		expect(scope.createdAt).toBeGreaterThan(0);
+	});
+});
+
+describe("setTTL", () => {
+	it("updates ttl", () => {
+		const scope = createSessionScope("s1");
+		const updated = setTTL(scope, 60_000);
+		expect(updated.ttlMs).toBe(60_000);
+		expect(updated.id).toBe("s1");
+	});
+});
+
+describe("addToScope", () => {
+	it("appends item", () => {
+		const scope = createSessionScope("s1");
+		const item = makeItem({ id: "i1" });
+		const updated = addToScope(scope, item);
+		expect(updated.items).toHaveLength(1);
+		expect(updated.items[0].id).toBe("i1");
+	});
+});
+
+describe("evictExpired", () => {
+	it("removes expired items", () => {
+		const scope = createSessionScope("s1");
+		const item1 = makeItem({ id: "i1", expiresAt: Date.now() + 10000 });
+		const item2 = makeItem({ id: "i2", expiresAt: Date.now() - 1000 });
+		const updated = addToScope(addToScope(scope, item1), item2);
+		const evicted = evictExpired(updated);
+		expect(evicted.items.map((i) => i.id)).toEqual(["i1"]);
+	});
+
+	it("keeps items without expiry", () => {
+		const scope = createSessionScope("s1");
+		const item = makeItem({ id: "i1" });
+		const updated = addToScope(scope, item);
+		expect(evictExpired(updated).items).toHaveLength(1);
+	});
+});
+
+describe("prioritize", () => {
+	it("sorts by priority ascending", () => {
+		const items = [
+			makeItem({ id: "low", priority: 9 }),
+			makeItem({ id: "high", priority: 1 }),
+			makeItem({ id: "mid", priority: 5 }),
+		];
+		const sorted = prioritize(items);
+		expect(sorted.map((i) => i.id)).toEqual(["high", "mid", "low"]);
+	});
+
+	it("respects limit", () => {
+		const items = [
+			makeItem({ id: "a", priority: 3 }),
+			makeItem({ id: "b", priority: 1 }),
+			makeItem({ id: "c", priority: 2 }),
+		];
+		expect(prioritize(items, 2)).toHaveLength(2);
+	});
+});
+
+describe("estimateTokens", () => {
+	it("counts chars/4", () => expect(estimateTokens("abcdefgh")).toBe(2));
+	it("rounds up", () => expect(estimateTokens("abc")).toBe(1));
+});
+
+describe("calculateTotalTokens", () => {
+	it("sums tokens", () => {
+		const items = [makeItem({ tokens: 10 }), makeItem({ tokens: 20 })];
+		expect(calculateTotalTokens(items)).toBe(30);
+	});
+	it("empty returns 0", () => expect(calculateTotalTokens([])).toBe(0));
+});
+
+describe("compactContext", () => {
+	it("extracts decisions", () => {
+		const items = [makeItem({ content: "DECISION: use tRPC for API" })];
+		const result = compactContext(items, 1000);
+		expect(result.decisions.length).toBeGreaterThan(0);
+	});
+
+	it("extracts questions", () => {
+		const items = [
+			makeItem({
+				content: "Should we use Redis? TODO: decide caching strategy",
+			}),
+		];
+		const result = compactContext(items, 1000);
+		expect(result.openQuestions.length).toBeGreaterThan(0);
+	});
+
+	it("respects maxTokens threshold", () => {
+		const items = [makeItem({ tokens: 100 })];
+		const result = compactContext(items, 50);
+		expect(result.remainingTokens).toBeLessThan(100);
+	});
+});
+
+describe("generateResumePrompt", () => {
+	it("creates prompt from result", () => {
+		const result = compactContext([], 1000);
+		const prompt = generateResumePrompt(result, "Continue with API");
+		expect(prompt.nextAction).toBe("Continue with API");
+		expect(prompt.decisions).toEqual([]);
+	});
+});
+
+describe("formatResumeMarkdown", () => {
+	it("includes headings", () => {
+		const prompt = generateResumePrompt(
+			{
+				decisions: ["Use tRPC"],
+				openQuestions: ["Which DB?"],
+				taskProgress: {},
+				remainingTokens: 100,
+				compactedContent: "",
+			},
+			"Continue",
+		);
+		const md = formatResumeMarkdown(prompt);
+		expect(md).toContain("# Resume Prompt");
+		expect(md).toContain("## Decisions");
+		expect(md).toContain("## Next Action");
+	});
+});

package/packages/cookie-sanitizer/README.md

@@ -0,0 +1,141 @@
+# @pi-harness/cookie-sanitizer
+
+> Forgiving input -> strict canonical cache for provider-quota mirroring.
+
+A normalization boundary that lets users drop **any** cookie file (any name, any format) into a known folder, and turns it into a single standard Netscape file the rest of the runtime can rely on.
+
+```
+~/.pi-harness-runtime/cookies/          <-  user drops anything here
+            |
+            ▼
+   Cookie Sanitizer                     <-  THIS PACKAGE
+            |
+            ▼
+~/.config/<provider>-cookies.txt        <-  canonical, runtime-owned
+            |
+            ▼
+   MiniMaxQuotaScraper (unchanged)      <-  reads only the canonical
+```
+
+## Why
+
+The previous design expected users to know the exact path (`~/.config/minimax-cookies.txt`) and the exact format (Netscape). On a fresh machine, no-one ever set this up — the scraper silently no-op'd and the footer lost its `5h:` / `week:` lines. This package is the discoverable, forgiving adapter between messy human input and the clean contract downstream code already understands.
+
+## What it accepts
+
+**Input formats** (auto-detected per file):
+
+1. **Netscape HTTP Cookie File** — the canonical format
+2. **EditThisCookie / Chrome devtools JSON export** — array of records in the Chrome/Edge cookie store shape
+
+**File names** — any name in the drop folder. Inference prefers:
+
+1. Filename hint (`minimax-*.txt`, `*claude*`, etc.) -> provider
+2. Dominant cookie domain (≥ 80% match) -> provider
+3. `providerHint` option overrides all of the above
+
+**Provider scope** — currently shipping with: `minimax`, `anthropic`, `openai`, `glm`, `openrouter`. The registry is open and inference by domain works for any provider whose cookies are in the drop folder.
+
+## Usage
+
+### One-shot sync
+
+```typescript
+import { sync } from "@pi-harness/cookie-sanitizer";
+
+const result = sync();
+
+if (result.wrote) {
+  console.log(`Synced ${result.totalCookies} cookies for ${result.provider} -> ${result.cachePath}`);
+} else {
+  console.log(`No-op: ${result.errors[0]?.message ?? "nothing to sync"}`);
+}
+```
+
+### Live watcher
+
+```typescript
+import { CookieWatcher } from "@pi-harness/cookie-sanitizer";
+
+const watcher = new CookieWatcher({
+  dropDir: "~/.pi-harness-runtime/cookies",
+  onEvent: (e) => {
+    if (e.kind === "sync-ok") console.log(`Synced ${e.cookies} cookies -> ${e.cachePath}`);
+    if (e.kind === "sync-error") console.error(`Sync error: ${e.message}`);
+  },
+});
+
+watcher.start();
+// ... later
+await watcher.stop();
+```
+
+### Custom drop folder / cache path
+
+```typescript
+import { sync } from "@pi-harness/cookie-sanitizer";
+
+const result = sync({
+  dropDir: "/var/spool/cookies",
+  cachePath: "/var/spool/canonical/minimax-cookies.txt",
+  providerHint: "minimax", // skip inference
+});
+```
+
+## Storage contract
+
+| Path | Owned by | Mode | Format |
+|---|---|---|---|
+| `~/.pi-harness-runtime/cookies/` | user (writes freely) | `0o644` | anything |
+| `~/.config/<provider>-cookies.txt` | sanitizer (single writer) | `0o600` | standard Netscape |
+
+The sanitizer is the **only** writer of the canonical cache. Manual edits are overwritten on next sync — by design. If you want a manual override, set `QUOTA_COOKIE_FILE` env var to a different path; the sanitizer will then skip its work and the scraper reads the override directly.
+
+## What is NOT logged
+
+- Cookie **values** — never. Diagnostics use file basenames and 64-char previews with values redacted.
+- Cookie **paths** (except the canonical cache path, which is a configuration location).
+- Cookie **domains** are OK to print (public).
+
+## Tests
+
+```bash
+bun test                 # all package tests
+bun test test/parse.test.ts
+bun test test/sync.test.ts
+```
+
+## Security
+
+- The canonical cache is `0o600` (owner R/W only) — atomic write with `0o600` parent, `fsync` before `rename`, `chmod` to `0o600` after rename.
+- The drop folder is gitignored by convention (`.gitleaks.toml` allowlists `cookies.txt` files in both locations).
+- `chokidar` v5 watches the drop folder; sandboxed to `depth: 2` so we don't follow symlinks into the rest of the home directory.
+
+## Files
+
+```
+src/
++-- index.ts            # public API surface
++-- types.ts            # canonical types
++-- detect-format.ts    # Netscape vs JSON detection
++-- parse-netscape.ts   # Netscape parser + serializer
++-- parse-json.ts       # EditThisCookie JSON parser
++-- normalize.ts        # dedupe, expire, domain-match
++-- infer-provider.ts   # filename + domain inference
++-- atomic-write.ts     # POSIX atomic write
++-- sync.ts             # orchestrator
++-- watcher.ts          # chokidar v5 wrapper
+
+test/
++-- parse.test.ts       # 14 cases — Netscape + JSON
++-- normalize.test.ts   # 12 cases — dedupe/expire/domain
++-- infer.test.ts       # 13 cases — filename + domain + combined
++-- sync.test.ts        # 12 cases — end-to-end
++-- watcher.test.ts     # 2 cases — config sanity (chokidar is exercised live)
+```
+
+## Limitations
+
+- Watcher tests are light-touch (chokidar needs a real OS-level fs watcher). Real behavior is exercised by the live runtime.
+- Multi-format inputs (e.g. raw `Cookie:` headers, single-line `k=v`) are deferred. Add on demand.
+- Provider scope is currently hard-coded to a small set. Adding a new provider = adding an entry in `infer-provider.ts`.

package/packages/cookie-sanitizer/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@pi-harness/cookie-sanitizer",
+  "version": "0.10.30",
+  "description": "pi-harness-runtime — cookie sanitizer (provider-quota cookie file normaliser)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@types/node": ">=20"
+  }
+}

package/packages/cookie-sanitizer/test/infer.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Provider inference tests.
+ *
+ * Three inference passes:
+ *   1. filename hint
+ *   2. dominant domain (>= 80%)
+ *   3. null
+ *
+ * The `hint` parameter overrides all of the above.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	inferProvider,
+	inferProviderFromFilename,
+	inferProviderFromCookies,
+	knownProviders,
+} from "../src/infer-provider.js";
+import type { CanonicalCookie } from "../src/types.js";
+
+function cookie(domain: string, name = "n"): CanonicalCookie {
+	return {
+		name,
+		value: "v",
+		domain,
+		path: "/",
+		secure: false,
+		httpOnly: false,
+	};
+}
+
+describe("inferProviderFromFilename", () => {
+	it("matches known providers by name fragment", () => {
+		expect(inferProviderFromFilename("minimax-cookies.txt")).toBe("minimax");
+		expect(inferProviderFromFilename("anthropic-session.json")).toBe(
+			"anthropic",
+		);
+		expect(inferProviderFromFilename("openai-tokens.json")).toBe("openai");
+		expect(inferProviderFromFilename("glm-export.json")).toBe("glm");
+	});
+
+	it("returns null for unknown names", () => {
+		expect(inferProviderFromFilename("random-export.json")).toBe(null);
+		expect(inferProviderFromFilename("")).toBe(null);
+	});
+});
+
+describe("inferProviderFromCookies", () => {
+	it("returns provider when ≥ 80% of cookies match one domain", () => {
+		const cookies = [
+			cookie(".minimax.io"),
+			cookie("platform.minimax.io"),
+			cookie(".minimax.io"),
+			cookie(".minimax.io"),
+			cookie(".other.com", "x"),
+		];
+		// 4/5 = 80% → matches minimax
+		expect(inferProviderFromCookies(cookies)).toBe("minimax");
+	});
+
+	it("returns null when no single provider dominates", () => {
+		const cookies = [
+			cookie(".minimax.io", "a"),
+			cookie(".anthropic.com", "b"),
+			cookie(".openai.com", "c"),
+		];
+		expect(inferProviderFromCookies(cookies)).toBe(null);
+	});
+
+	it("returns null for empty input", () => {
+		expect(inferProviderFromCookies([])).toBe(null);
+	});
+});
+
+describe("inferProvider (combined)", () => {
+	it("explicit hint wins over everything", () => {
+		const cookies = [cookie(".minimax.io")];
+		expect(inferProvider("anthropic.json", cookies, "openai")).toBe("openai");
+	});
+
+	it("filename hint wins over domain inference", () => {
+		const cookies = [cookie(".openai.com")];
+		expect(inferProvider("minimax-2026.json", cookies)).toBe("minimax");
+	});
+
+	it("falls through to domain inference when no filename match", () => {
+		const cookies = [
+			cookie(".anthropic.com"),
+			cookie(".anthropic.com"),
+			cookie(".anthropic.com"),
+			cookie(".anthropic.com"),
+		];
+		expect(inferProvider("random.txt", cookies)).toBe("anthropic");
+	});
+
+	it("returns null when nothing matches", () => {
+		expect(inferProvider("random.txt", [cookie(".other.com")])).toBe(null);
+	});
+});
+
+describe("knownProviders", () => {
+	it("returns at least the bundled providers", () => {
+		const providers = knownProviders();
+		expect(providers).toContain("minimax");
+		expect(providers).toContain("anthropic");
+		expect(providers).toContain("openai");
+		expect(providers).toContain("glm");
+		expect(providers).toContain("openrouter");
+	});
+});

package/packages/cookie-sanitizer/test/normalize.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Normalization tests — dedupe, expire, domain-match, tag.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	normalize,
+	domainMatchesProvider,
+	isExpired,
+} from "../src/normalize.js";
+import type { CanonicalCookie } from "../src/types.js";
+
+const NOW = 1_700_000_000;
+
+function cookie(over: Partial<CanonicalCookie> = {}): CanonicalCookie {
+	return {
+		name: "n1",
+		value: "v1",
+		domain: ".minimax.io",
+		path: "/",
+		secure: false,
+		httpOnly: false,
+		...over,
+	};
+}
+
+describe("domainMatchesProvider", () => {
+	it("matches minimax subdomains", () => {
+		expect(domainMatchesProvider(".minimax.io", "minimax")).toBe(true);
+		expect(domainMatchesProvider("platform.minimax.io", "minimax")).toBe(true);
+	});
+
+	it("rejects unrelated domains", () => {
+		expect(domainMatchesProvider(".example.com", "minimax")).toBe(false);
+	});
+
+	it("accepts all domains for unknown provider (let downstream reject)", () => {
+		expect(domainMatchesProvider(".anything.tld", "weird-provider")).toBe(true);
+	});
+});
+
+describe("isExpired", () => {
+	it("returns false for session cookies", () => {
+		expect(isExpired(cookie({ expires: undefined }), NOW)).toBe(false);
+		expect(isExpired(cookie({ expires: 0 }), NOW)).toBe(false);
+	});
+
+	it("returns true for past timestamps", () => {
+		expect(isExpired(cookie({ expires: NOW - 1 }), NOW)).toBe(true);
+	});
+
+	it("returns false for future timestamps", () => {
+		expect(isExpired(cookie({ expires: NOW + 1 }), NOW)).toBe(false);
+	});
+});
+
+describe("normalize", () => {
+	it("dedupes by (domain, name); last wins", () => {
+		const input: CanonicalCookie[] = [
+			cookie({ name: "n", value: "v1" }),
+			cookie({ name: "n", value: "v2" }),
+		];
+		const out = normalize(input, "minimax", NOW);
+		expect(out).toHaveLength(1);
+		expect(out[0]?.value).toBe("v2");
+	});
+
+	it("drops empty name/value", () => {
+		const input: CanonicalCookie[] = [
+			cookie({ name: "" }),
+			cookie({ value: "" }),
+			cookie({ name: "ok", value: "v" }),
+		];
+		const out = normalize(input, "minimax", NOW);
+		expect(out).toHaveLength(1);
+		expect(out[0]?.name).toBe("ok");
+	});
+
+	it("drops expired cookies", () => {
+		const input: CanonicalCookie[] = [
+			cookie({ expires: NOW - 100 }),
+			cookie({ expires: NOW + 100 }),
+		];
+		const out = normalize(input, "minimax", NOW);
+		expect(out).toHaveLength(1);
+		expect(out[0]?.expires).toBe(NOW + 100);
+	});
+
+	it("drops cookies whose domain doesn't match provider", () => {
+		const input: CanonicalCookie[] = [
+			cookie({ domain: ".minimax.io" }),
+			cookie({ domain: ".other.com", name: "other" }),
+		];
+		const out = normalize(input, "minimax", NOW);
+		expect(out).toHaveLength(1);
+		expect(out[0]?.domain).toBe(".minimax.io");
+	});
+
+	it("tags each surviving cookie with the provider", () => {
+		const input: CanonicalCookie[] = [
+			cookie({ name: "n1" }),
+			cookie({ name: "n2" }),
+		];
+		const out = normalize(input, "minimax", NOW);
+		for (const c of out) {
+			expect(c.provider).toBe("minimax");
+		}
+	});
+
+	it("returns empty array on empty input", () => {
+		expect(normalize([], "minimax", NOW)).toEqual([]);
+	});
+});