pi-harness-runtime 0.10.11 → 0.10.12

package/packages/context-manager/src/compaction.ts

@@ -0,0 +1,139 @@
+/**
+ * Context Manager — Compaction Engine (RFC-0010)
+ */
+
+import type {
+	ContextItem,
+	CompactionResult,
+	ResumePrompt,
+	TriggerPolicy,
+} from "./types.js";
+import { DEFAULT_POLICY } from "./core.js";
+import { prioritize } from "./core.js";
+
+/** Extract decisions from messages (lines starting with DECISION markers). */
+function extractDecisions(messages: ContextItem[]): string[] {
+	const decisions: string[] = [];
+	for (const msg of messages) {
+		for (const line of msg.content.split("\n")) {
+			const trimmed = line.trim();
+			if (
+				trimmed.startsWith("- DECISION:") ||
+				trimmed.startsWith("**DECISION**") ||
+				/^(?:decision|decided):/i.test(trimmed)
+			) {
+				decisions.push(trimmed.replace(/^[*>-]+\s*/i, "").trim());
+			}
+		}
+	}
+	return [...new Set(decisions)];
+}
+
+/** Extract open questions (lines with ?, TODO, TBD, OPEN markers). */
+function extractQuestions(messages: ContextItem[]): string[] {
+	const questions: string[] = [];
+	for (const msg of messages) {
+		for (const line of msg.content.split("\n")) {
+			const trimmed = line.trim();
+			if (
+				trimmed.includes("?") ||
+				/\bTODO\b/i.test(trimmed) ||
+				/\bTBD\b/i.test(trimmed)
+			) {
+				const cleaned = trimmed.replace(/^[*>-]+\s*/, "").trim();
+				if (cleaned.length > 5) questions.push(cleaned);
+			}
+		}
+	}
+	return [...new Set(questions)];
+}
+
+/** Extract task progress from messages. */
+function extractTaskProgress(messages: ContextItem[]): Record<string, string> {
+	const progress: Record<string, string> = {};
+	for (const msg of messages) {
+		for (const line of msg.content.split("\n")) {
+			const match = line.match(
+				/^(?:progress|task|step)[:\s]+([^|]+)\|\s*(.+)/i,
+			);
+			if (match) progress[match[1].trim()] = match[2].trim();
+		}
+	}
+	return progress;
+}
+
+/** Compact context by extracting durable state and keeping high-priority items. */
+export function compactContext(
+	messages: ContextItem[],
+	maxTokens: number,
+	policy: TriggerPolicy = DEFAULT_POLICY,
+): CompactionResult {
+	const decisions = extractDecisions(messages);
+	const openQuestions = extractQuestions(messages);
+	const taskProgress = extractTaskProgress(messages);
+
+	const prioritized = prioritize(messages, Math.floor(messages.length * 0.6));
+	let tokenCount = 0;
+	const kept: string[] = [];
+
+	for (const msg of prioritized) {
+		if (
+			tokenCount + msg.tokens <=
+			Math.floor(maxTokens * policy.compactThreshold)
+		) {
+			kept.push(msg.content);
+			tokenCount += msg.tokens;
+		}
+	}
+
+	return {
+		decisions,
+		openQuestions,
+		taskProgress,
+		remainingTokens: tokenCount,
+		compactedContent: kept.join("\n\n"),
+	};
+}
+
+/** Generate a resume prompt from compaction result. */
+export function generateResumePrompt(
+	result: CompactionResult,
+	nextAction?: string,
+): ResumePrompt {
+	const summary = [
+		"## Session Summary",
+		`Decisions: ${result.decisions.length > 0 ? result.decisions.join("; ") : "none"}`,
+		`Questions: ${result.openQuestions.length > 0 ? result.openQuestions.join("; ") : "none"}`,
+		`Context size: ${result.remainingTokens} tokens`,
+	].join("\n");
+
+	return {
+		summary,
+		decisions: result.decisions,
+		openQuestions: result.openQuestions,
+		taskProgress: result.taskProgress,
+		nextAction: nextAction ?? "Continue from last position",
+	};
+}
+
+/** Format resume prompt as markdown string. */
+export function formatResumeMarkdown(prompt: ResumePrompt): string {
+	const lines = [
+		"# Resume Prompt",
+		"",
+		prompt.summary,
+		"",
+		"## Decisions",
+		...prompt.decisions.map((d) => `- ${d}`),
+		"",
+		"## Open Questions",
+		...prompt.openQuestions.map((q) => `- ${q}`),
+		"",
+		"## Task Progress",
+		...Object.entries(prompt.taskProgress).map(([k, v]) => `- **${k}**: ${v}`),
+		"",
+		"## Next Action",
+		`- ${prompt.nextAction}`,
+	];
+	return lines.filter((l) => l).join("\n");
+}

package/packages/context-manager/src/core.ts

@@ -0,0 +1,85 @@
+/**
+ * Context Manager Core — pressure estimation, TTL, prioritization (RFC-0010)
+ */
+
+import type {
+	PressureLevel,
+	TriggerPolicy,
+	ContextItem,
+	SessionScope,
+} from "./types.js";
+
+export const DEFAULT_POLICY: TriggerPolicy = {
+	warningThreshold: 0.6,
+	compactThreshold: 0.7,
+	hardStopThreshold: 0.85,
+};
+
+/** Estimate context pressure as a ratio (0-1). */
+export function estimatePressure(
+	currentTokens: number,
+	maxTokens: number,
+): number {
+	if (maxTokens <= 0) return 1;
+	return Math.min(currentTokens / maxTokens, 1);
+}
+
+/** Determine pressure level from a ratio. */
+export function getPressureLevel(
+	pressure: number,
+	policy: TriggerPolicy = DEFAULT_POLICY,
+): PressureLevel {
+	if (pressure >= policy.hardStopThreshold) return "hard_stop";
+	if (pressure >= policy.compactThreshold) return "compact";
+	if (pressure >= policy.warningThreshold) return "warning";
+	return "normal";
+}
+
+/** Create a new session-scoped context bucket. */
+export function createSessionScope(id: string): SessionScope {
+	return { id, items: [], ttlMs: 30 * 60 * 1000, createdAt: Date.now() };
+}
+
+/** Set TTL on a scope (in milliseconds). */
+export function setTTL(scope: SessionScope, ttlMs: number): SessionScope {
+	return { ...scope, ttlMs };
+}
+
+/** Add an item to a session scope. */
+export function addToScope(
+	scope: SessionScope,
+	item: ContextItem,
+): SessionScope {
+	return { ...scope, items: [...scope.items, item] };
+}
+
+/** Remove expired items from a scope based on TTL. */
+export function evictExpired(scope: SessionScope): SessionScope {
+	const now = Date.now();
+	return {
+		...scope,
+		items: scope.items.filter((item) => {
+			if (!item.expiresAt) return true;
+			return item.expiresAt > now;
+		}),
+	};
+}
+
+/** Prioritize items: lower priority number = higher importance. */
+export function prioritize(
+	items: ContextItem[],
+	limit?: number,
+): ContextItem[] {
+	const sorted = [...items].sort((a, b) => a.priority - b.priority);
+	return limit ? sorted.slice(0, limit) : sorted;
+}
+
+/** Count tokens using a simple word-based estimator (4 chars/token). */
+export function estimateTokens(text: string): number {
+	return Math.ceil(text.length / 4);
+}
+
+/** Calculate total tokens in a list of items. */
+export function calculateTotalTokens(items: ContextItem[]): number {
+	return items.reduce((sum, item) => sum + item.tokens, 0);
+}

package/packages/context-manager/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * Context Manager — Main Entry (RFC-0010)
+ */
+
+export {
+	DEFAULT_POLICY,
+	estimatePressure,
+	getPressureLevel,
+	createSessionScope,
+	setTTL,
+	addToScope,
+	evictExpired,
+	prioritize,
+	estimateTokens,
+	calculateTotalTokens,
+} from "./core.js";
+export {
+	compactContext,
+	generateResumePrompt,
+	formatResumeMarkdown,
+} from "./compaction.js";
+export type * from "./types.js";

package/packages/context-manager/src/types.ts

@@ -0,0 +1,44 @@
+/**
+ * Context Manager Types (RFC-0010)
+ */
+
+export type PressureLevel = "normal" | "warning" | "compact" | "hard_stop";
+
+export interface TriggerPolicy {
+	warningThreshold: number;
+	compactThreshold: number;
+	hardStopThreshold: number;
+}
+
+export interface ContextItem {
+	id: string;
+	role: "user" | "assistant" | "system";
+	content: string;
+	tokens: number;
+	priority: number;
+	timestamp: number;
+	expiresAt?: number;
+}
+
+export interface CompactionResult {
+	decisions: string[];
+	openQuestions: string[];
+	taskProgress: Record<string, string>;
+	remainingTokens: number;
+	compactedContent: string;
+}
+
+export interface SessionScope {
+	id: string;
+	items: ContextItem[];
+	ttlMs: number;
+	createdAt: number;
+}
+
+export interface ResumePrompt {
+	summary: string;
+	decisions: string[];
+	openQuestions: string[];
+	taskProgress: Record<string, string>;
+	nextAction: string;
+}

package/packages/cookie-sanitizer/src/atomic-write.ts

@@ -0,0 +1,79 @@
+/**
+ * Atomic file write — write to temp, fsync, then rename.
+ *
+ * POSIX `rename(2)` is atomic — on partial-write crash, the prior target
+ * file remains valid. We pair this with `fsync(tempfile)` so the temp
+ * file's data is durable on disk before the rename.
+ *
+ * Permissions: `0o600` (owner R/W only) to keep the canonical cache
+ * owner-readable.
+ *
+ * Sec-001: Cookie values go into the file content. The caller is
+ * responsible for value-handling hygiene; this module just writes
+ * bytes. We do not log the content.
+ */
+
+import {
+	mkdirSync,
+	openSync,
+	writeSync,
+	fsyncSync,
+	closeSync,
+	renameSync,
+	chmodSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import type { ProviderId } from "./types.js";
+
+/**
+ * Atomically write `content` to `finalPath`.
+ *
+ * Steps:
+ *   1. mkdir -p the parent directory
+ *   2. write to <finalPath>.tmp.<rand>  with mode 0o600
+ *   3. fsync the temp file
+ *   4. rename temp → final  (atomic on POSIX)
+ *   5. chmod final to 0o600  (in case rename preserved looser perms)
+ *
+ * Throws if any step fails. The original `finalPath` is unchanged
+ * until step 4 succeeds.
+ */
+export function atomicWriteFileSync(finalPath: string, content: string): void {
+	mkdirSync(dirname(finalPath), { recursive: true });
+
+	const rand = randomBytes(6).toString("hex");
+	const tempPath = `${finalPath}.tmp.${rand}`;
+
+	let fd: number | undefined;
+	try {
+		fd = openSync(tempPath, "w", 0o600);
+		writeSync(fd, Buffer.from(content, "utf8"));
+		fsyncSync(fd);
+	} finally {
+		if (fd !== undefined) closeSync(fd);
+	}
+
+	renameSync(tempPath, finalPath);
+
+	// Belt-and-braces in case rename preserved a looser mode from an
+	// existing file on some systems.
+	try {
+		chmodSync(finalPath, 0o600);
+	} catch {
+		// Filesystems that don't support chmod (e.g. FAT32) are not a
+		// target platform here — drop the error silently.
+	}
+}
+
+/**
+ * Compute the default cache path for a given provider, e.g.:
+ *   defaultCachePathFor("minimax") → "~/.config/minimax-cookies.txt"
+ *
+ * The home directory is read via `process.env.HOME` so tests can
+ * override it.
+ */
+export function defaultCachePathFor(provider: ProviderId): string {
+	const home = process.env.HOME ?? "/tmp";
+	return join(home, ".config", `${provider}-cookies.txt`);
+}

package/packages/cookie-sanitizer/src/detect-format.ts

@@ -0,0 +1,102 @@
+/**
+ * Format detection — does the input look like Netscape or EditThisCookie JSON?
+ *
+ * Detection rule:
+ *  - File extension `.json` AND first non-blank byte is `[` or `{`  →  JSON
+ *  - File content has `# Netscape HTTP Cookie File` header OR
+ *    ≥ 1 tab-separated 7-column row                              →  Netscape
+ *  - Otherwise                                                    →  unknown
+ *
+ * Cookie VALUES are never copied into return values that get logged.
+ * Only the basename and a 64-char prefix of the first non-blank line.
+ */
+
+import { basename } from "node:path";
+import type { CookieFileFormat, DetectedFile } from "./types.js";
+
+const HEADER_RE = /^# Netscape HTTP Cookie File/im;
+const MIN_TAB_COLS = 7;
+
+/**
+ * Returns the basename only, never a path that could leak directory
+ * structure. Safe to log.
+ */
+export function safeBasename(filePath: string): string {
+	return basename(filePath);
+}
+
+/**
+ * Safely truncated preview of a file's content (for diagnostics).
+ * Strips cookie values to avoid leaking secrets.
+ *
+ * Heuristic: any line that has a tab-separated name=value pair,
+ * replace the value column with `<redacted>`.
+ */
+export function safePreview(text: string, maxChars = 64): string {
+	const firstLine =
+		text
+			.split("\n")
+			.map((l) => l.trim())
+			.find((l) => l.length > 0) ?? "";
+	const redacted = firstLine
+		.split("\t")
+		.map((col, i) => (i >= 5 ? "<redacted>" : col))
+		.join("\t");
+	return redacted.length > maxChars
+		? `${redacted.slice(0, maxChars)}…`
+		: redacted;
+}
+
+/**
+ * Detect the format of cookie file text.
+ */
+export function detectFormat(text: string): CookieFileFormat | null {
+	if (typeof text !== "string" || text.length === 0) return null;
+
+	const trimmed = text.trimStart();
+	const firstByte = trimmed[0];
+
+	// JSON heuristic — array or object at the top.
+	if (firstByte === "[" || firstByte === "{") {
+		return "edit-this-cookie-json";
+	}
+
+	// Netscape heuristic — header OR a tab-separated 7-column row.
+	if (HEADER_RE.test(text)) {
+		return "netscape";
+	}
+
+	const lines = text.split(/\r?\n/);
+	for (const line of lines) {
+		if (!line || (line.startsWith("#") && !line.startsWith("#HttpOnly_"))) {
+			continue;
+		}
+		const trimmedLine = line.startsWith("#HttpOnly_")
+			? line.slice("#HttpOnly_".length)
+			: line;
+		const cols = trimmedLine.split("\t");
+		if (cols.length >= MIN_TAB_COLS) {
+			return "netscape";
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Build a DetectedFile from a path and its text contents.
+ * Used by sync.ts after reading the file from disk.
+ */
+export function buildDetectedFile(
+	filePath: string,
+	text: string,
+): DetectedFile {
+	const format = detectFormat(text);
+	return {
+		path: filePath,
+		basename: safeBasename(filePath),
+		format,
+		text,
+		// No error if format is null — unknown format is a normal case.
+	};
+}

package/packages/cookie-sanitizer/src/index.ts

@@ -0,0 +1,89 @@
+/**
+ * Cookie Sanitizer — public API.
+ *
+ * Forgiving input → strict canonical cache for downstream consumers
+ * (e.g. MiniMaxQuotaScraper reads only `~/.config/minimax-cookies.txt`).
+ *
+ * The package is provider-agnostic but currently shipping with:
+ *   - filename hints: minimax, anthropic, openai, glm, openrouter
+ *   - domain hints : the matching provider domains
+ *
+ * Inputs accepted (auto-detected per file):
+ *   - Netscape HTTP Cookie File
+ *   - EditThisCookie / Chrome devtools JSON export
+ *
+ * @example
+ * ```typescript
+ * import { sync, hasAnyCookieSource, CookieWatcher } from "@pi-harness/cookie-sanitizer";
+ *
+ * // One-shot sync.
+ * const result = sync();
+ * console.log(result.provider, result.cachePath, result.totalCookies);
+ *
+ * // Live updates.
+ * const watcher = new CookieWatcher({
+ *   dropDir: "~/.pi-harness-runtime/cookies",
+ *   onEvent: (e) => console.log(e),
+ * });
+ * watcher.start();
+ * ```
+ */
+
+export {
+	sync,
+	hasAnyCookieSource,
+	inferCachePath,
+	enumerateDropFiles,
+	readInputFile,
+	DEFAULT_DROP_DIR,
+} from "./sync.js";
+
+export {
+	parseNetscape,
+	serializeNetscape,
+} from "./parse-netscape.js";
+
+export { parseEditThisCookieJson } from "./parse-json.js";
+
+export {
+	inferProvider,
+	inferProviderFromFilename,
+	inferProviderFromCookies,
+	knownProviders,
+} from "./infer-provider.js";
+
+export {
+	normalize,
+	domainMatchesProvider,
+	isExpired,
+} from "./normalize.js";
+
+export {
+	detectFormat,
+	buildDetectedFile,
+	safeBasename,
+	safePreview,
+} from "./detect-format.js";
+
+export {
+	atomicWriteFileSync,
+	defaultCachePathFor,
+} from "./atomic-write.js";
+
+export {
+	CookieWatcher,
+	createWatcher,
+	defaultDropDir,
+} from "./watcher.js";
+
+export type {
+	CanonicalCookie,
+	CookieFileFormat,
+	DetectedFile,
+	ProviderId,
+	SyncOptions,
+	SyncResult,
+	WatcherEvent,
+} from "./types.js";
+
+export type { CookieWatcherConfig } from "./watcher.js";

package/packages/cookie-sanitizer/src/infer-provider.ts

@@ -0,0 +1,103 @@
+/**
+ * Provider inference — figure out which provider a cookie dump belongs to
+ * without the user having to organize by subfolder.
+ *
+ * Three inference passes, first hit wins:
+ *   1. Filename hint    (e.g. `minimax-*.txt`, `*minimax.json` → "minimax")
+ *   2. Dominant domain  (≥ 80% of cookies on `*.minimax.io` → "minimax")
+ *   3. Nothing           → null (caller will surface a friendly error)
+ *
+ * Provider hint from SyncOptions overrides all of the above.
+ */
+
+import type { CanonicalCookie, ProviderId } from "./types.js";
+
+const FILENAME_HINTS: Array<{ pattern: RegExp; provider: ProviderId }> = [
+	{ pattern: /minimax/i, provider: "minimax" },
+	{ pattern: /anthropic|claude/i, provider: "anthropic" },
+	{ pattern: /openai|gpt|chatgpt/i, provider: "openai" },
+	{ pattern: /glm|z\.ai|zhipuai/i, provider: "glm" },
+	{ pattern: /openrouter/i, provider: "openrouter" },
+];
+
+const DOMAIN_HINTS: Array<{ pattern: RegExp; provider: ProviderId }> = [
+	{ pattern: /\.minimax\.io$|^minimax\.io$/i, provider: "minimax" },
+	{ pattern: /\.anthropic\.com$|^anthropic\.com$/i, provider: "anthropic" },
+	{
+		pattern: /\.openai\.com$|^openai\.com$|\.chatgpt\.com$|^chatgpt\.com$/i,
+		provider: "openai",
+	},
+	{
+		pattern: /\.z\.ai$|^z\.ai$|\.zhipuai\.cn$|^zhipuai\.cn$/i,
+		provider: "glm",
+	},
+	{ pattern: /\.openrouter\.ai$|^openrouter\.ai$/i, provider: "openrouter" },
+];
+
+/** Returns the first provider whose filename pattern matches, or null. */
+export function inferProviderFromFilename(filename: string): ProviderId | null {
+	if (!filename) return null;
+	for (const { pattern, provider } of FILENAME_HINTS) {
+		if (pattern.test(filename)) return provider;
+	}
+	return null;
+}
+
+/** Returns the provider whose domain is the dominant (≥ 80%) match. */
+export function inferProviderFromCookies(
+	cookies: CanonicalCookie[],
+): ProviderId | null {
+	if (!Array.isArray(cookies) || cookies.length === 0) return null;
+
+	const counts = new Map<ProviderId, number>();
+	let total = 0;
+	for (const c of cookies) {
+		if (!c.domain) continue;
+		total += 1;
+		for (const { pattern, provider } of DOMAIN_HINTS) {
+			if (pattern.test(c.domain.toLowerCase())) {
+				counts.set(provider, (counts.get(provider) ?? 0) + 1);
+				break;
+			}
+		}
+	}
+
+	if (total === 0) return null;
+	const threshold = Math.ceil(total * 0.8); // ≥ 80 %
+	let best: { provider: ProviderId; count: number } | null = null;
+	for (const [provider, count] of counts) {
+		if (count >= threshold && (!best || count > best.count)) {
+			best = { provider, count };
+		}
+	}
+	return best?.provider ?? null;
+}
+
+/**
+ * Combined inference: hint → filename → dominant domain → null.
+ *
+ * If `filename` is provided it takes priority over domain inference
+ * (filename hints are explicit). Domain inference is the fallback.
+ */
+export function inferProvider(
+	filename: string | undefined,
+	cookies: CanonicalCookie[],
+	hint?: ProviderId,
+): ProviderId | null {
+	if (hint) return hint;
+	if (filename) {
+		const fromName = inferProviderFromFilename(filename);
+		if (fromName) return fromName;
+	}
+	return inferProviderFromCookies(cookies);
+}
+
+/**
+ * Build a list of provider rules used by other parts of the package.
+ * Exposed for UI display (e.g. "which providers does this sanitizer know?").
+ */
+export function knownProviders(): ProviderId[] {
+	const set = new Set<ProviderId>();
+	for (const { provider } of FILENAME_HINTS) set.add(provider);
+	return Array.from(set);
+}