pi-harness-runtime 0.10.43 → 1.1.1

package/packages/auth/README.md

@@ -0,0 +1,60 @@
+# Auth Package
+
+Safe browser authentication for pi-harness-runtime.
+
+## Purpose
+
+Provides a secure way to authenticate with provider websites (like MiniMax) using a Playwright-managed browser profile. The human owns the authentication - the agent never sees credentials.
+
+## Security Rules
+
+- Human logs in manually in the browser
+- No username, password, raw cookies, or session tokens stored
+- Only a safe status file is written
+- Agent can only check if authentication succeeded
+
+## Files
+
+- `src/minimax-browser-auth.ts` - Main auth module
+- `src/run-minimax-auth.ts` - CLI runner
+
+## Usage
+
+```bash
+# Authenticate (opens browser for manual login)
+bun packages/auth/src/run-minimax-auth.ts auth
+
+# Check authentication status
+bun packages/auth/src/run-minimax-auth.ts check
+```
+
+## Storage
+
+- **Browser profile**: `~/.pi-harness-runtime/browser-profiles/minimax/`
+- **Status file**: `~/.pi-harness-runtime/auth/minimax-auth-status.json`
+
+## Status File Format
+
+```json
+{
+  "provider": "minimax",
+  "authenticated": true,
+  "checked_at": "2026-07-04T08:00:00.000Z",
+  "page_url": "https://platform.minimax.io/console/usage",
+  "detected_text_sample": "Usage Plan Credits Reset"
+}
+```
+
+## What is NOT stored
+
+- Passwords
+- Raw cookies
+- Session tokens
+- LocalStorage values
+- API keys
+
+## Limitations
+
+- Requires a display (headed browser mode)
+- Works on Mac/Linux with display
+- Cannot run in truly headless environments without Xvfb

package/packages/auth/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/auth",
+  "version": "0.10.30",
+  "description": "pi-harness-runtime — auth",
+  "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": {}
+}

package/packages/auth/test/auth.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Auth Tests — Filesystem helpers and pure functions (no browser required)
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+	detectUsagePage,
+	extractUsageLines,
+	getRuntimeDir,
+	getProfileDir,
+	getStatusPath,
+	getLiveSessionPath,
+	saveAuthStatus,
+	loadLiveBrowserSession,
+} from "../src/minimax-browser-auth";
+import {
+	existsSync,
+	mkdirSync,
+	rmSync,
+	writeFileSync,
+	readFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+const TMP = join(process.cwd(), ".test-auth-tmp");
+
+function tmpStatus() {
+	return join(TMP, "auth-status.json");
+}
+function tmpLiveSession() {
+	return join(TMP, "live-session.json");
+}
+
+beforeEach(() => {
+	rmSync(TMP, { force: true, recursive: true });
+	mkdirSync(TMP, { recursive: true });
+});
+
+describe("path helpers", () => {
+	it("getRuntimeDir returns a path with pi-harness-runtime", () => {
+		expect(getRuntimeDir()).toContain(".pi-harness-runtime");
+	});
+
+	it("getProfileDir is under runtime dir", () => {
+		expect(getProfileDir()).toStartWith(getRuntimeDir());
+		expect(getProfileDir()).toContain("minimax");
+	});
+
+	it("getStatusPath is under runtime dir", () => {
+		expect(getStatusPath()).toStartWith(getRuntimeDir());
+		expect(getStatusPath()).toContain("auth");
+	});
+
+	it("getLiveSessionPath contains session file name", () => {
+		expect(getLiveSessionPath()).toContain("minimax-live-browser");
+	});
+});
+
+describe("saveAuthStatus", () => {
+	beforeEach(() => {
+		rmSync(TMP, { force: true, recursive: true });
+		mkdirSync(TMP, { recursive: true });
+	});
+
+	it("writes a status file", () => {
+		const status = {
+			provider: "minimax" as const,
+			authenticated: true,
+			checked_at: "2025-01-15T10:00:00Z",
+			page_url: "https://platform.minimax.io/console/usage",
+			detected_text_sample: "Usage details",
+			profile_path: "/fake/profile",
+			usage_lines: ["Token Plan", "Monthly Plus", "Used 71%"],
+		};
+		saveAuthStatus(status, { statusPath: tmpStatus() });
+		expect(existsSync(tmpStatus())).toBe(true);
+		let loaded: any;
+		try {
+			loaded = JSON.parse(readFileSync(tmpStatus(), "utf-8"));
+		} catch {
+			throw new Error("saveAuthStatus did not write valid JSON");
+		}
+		expect(loaded.authenticated).toBe(true);
+		expect(loaded.provider).toBe("minimax");
+		expect(loaded.usage_lines).toHaveLength(3);
+	});
+
+	it("round-trips an unauthenticated status", () => {
+		const status = {
+			provider: "minimax" as const,
+			authenticated: false,
+			checked_at: "2025-01-15T10:00:00Z",
+			page_url: "",
+			detected_text_sample: null,
+			profile_path: "/fake/profile",
+			error_message: "Session expired",
+		};
+		saveAuthStatus(status, { statusPath: tmpStatus() });
+		let loaded: any;
+		try {
+			loaded = JSON.parse(readFileSync(tmpStatus(), "utf-8"));
+		} catch {
+			throw new Error("saveAuthStatus did not write valid JSON");
+		}
+		expect(loaded.authenticated).toBe(false);
+		expect(loaded.error_message).toBe("Session expired");
+	});
+
+	it("creates parent directories", () => {
+		const nestedPath = join(TMP, "deeply", "nested", "status.json");
+		saveAuthStatus(
+			{
+				provider: "minimax" as const,
+				authenticated: false,
+				checked_at: "",
+				page_url: "",
+				detected_text_sample: null,
+				profile_path: "/",
+			} as any,
+			{ statusPath: nestedPath },
+		);
+		expect(existsSync(nestedPath)).toBe(true);
+	});
+});
+
+describe("loadLiveBrowserSession", () => {
+	beforeEach(() => {
+		rmSync(TMP, { force: true, recursive: true });
+		mkdirSync(TMP, { recursive: true });
+	});
+
+	it("loads a saved session", () => {
+		const session = {
+			profile_path: "/tmp/chrome-profile",
+			target_url: "https://platform.minimax.io/console/usage",
+			chrome_path: "/usr/bin/google-chrome",
+			debugging_port: 9222,
+			pid: 12345,
+			started_at: "2025-01-15T10:00:00Z",
+		};
+		writeFileSync(tmpLiveSession(), JSON.stringify(session));
+		const loaded = loadLiveBrowserSession(tmpLiveSession());
+		expect(loaded?.debugging_port).toBe(9222);
+		expect(loaded?.pid).toBe(12345);
+		expect(loaded?.profile_path).toBe("/tmp/chrome-profile");
+	});
+
+	it("returns null for missing file", () => {
+		const loaded = loadLiveBrowserSession(join(TMP, "not-found.json"));
+		expect(loaded).toBeNull();
+	});
+
+	it("returns null for corrupted JSON", () => {
+		writeFileSync(tmpLiveSession(), "not json {");
+		const loaded = loadLiveBrowserSession(tmpLiveSession());
+		expect(loaded).toBeNull();
+	});
+});
+
+describe("detectUsagePage", () => {
+	it("detects page with usage keywords", () => {
+		const body =
+			"Your Usage: 5h limit, resets in 1 hour. Weekly limit used 71%. Token Plan · Monthly Plus";
+		const result = detectUsagePage(body);
+		expect(result.detected).toBe(true);
+		expect(result.sample).not.toBeNull();
+		expect(result.sample!.length).toBeGreaterThan(0);
+	});
+
+	it("does not detect page with few keywords", () => {
+		const body =
+			"Welcome to our website. This is a generic page with no usage information.";
+		const result = detectUsagePage(body);
+		expect(result.detected).toBe(false);
+		expect(result.sample).toBeNull();
+	});
+
+	it("triggers on 2+ matching keywords", () => {
+		const body = "Usage Quota limit exceeded";
+		const result = detectUsagePage(body);
+		expect(result.detected).toBe(true);
+	});
+
+	it("sample is truncated to 200 chars", () => {
+		const body =
+			"A".repeat(300) + " special_usage_keyword_here and another_token";
+		const result = detectUsagePage(body);
+		expect(result.detected).toBe(true);
+		expect(result.sample!.length).toBeLessThanOrEqual(200);
+	});
+
+	it("case insensitive matching", () => {
+		const body = "USAGE QUOTA TOKEN PLAN CREDITS";
+		const result = detectUsagePage(body);
+		expect(result.detected).toBe(true);
+	});
+
+	it("empty body returns not detected", () => {
+		const result = detectUsagePage("");
+		expect(result.detected).toBe(false);
+	});
+});
+
+describe("extractUsageLines", () => {
+	it("extracts lines with usage keywords", () => {
+		const body =
+			"<div>Your Token Plan</div><span>Monthly Plus</span><p>Used 71%</p>";
+		const lines = extractUsageLines(body);
+		expect(lines.length).toBeGreaterThan(0);
+	});
+
+	it("strips script and style tags", () => {
+		const body =
+			'<script>{"secret": true}</script><style>body{}</style>Visible content usage quota 71%';
+		const lines = extractUsageLines(body);
+		expect(lines.some((l) => l.includes("secret"))).toBe(false);
+	});
+
+	it("filters out overly short parts", () => {
+		const body = "ab cd ef gh ij usage token";
+		const lines = extractUsageLines(body);
+		for (const l of lines) {
+			expect(l.length).toBeGreaterThanOrEqual(3);
+		}
+	});
+
+	it("returns array for content-free input", () => {
+		const lines = extractUsageLines("<html><body></body></html>");
+		expect(Array.isArray(lines)).toBe(true);
+	});
+
+	it("deduplicates results", () => {
+		const body = "usage token 71% usage token 71%";
+		const lines = extractUsageLines(body);
+		const unique = [...new Set(lines)];
+		expect(lines.length).toBe(unique.length);
+	});
+});

package/packages/autonomous-refactor/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi/autonomous-refactor",
+  "version": "0.10.30",
+  "type": "module",
+  "description": "Autonomous refactoring engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0"
+  }
+}

package/packages/autonomous-refactor/test/refactor.test.ts

@@ -0,0 +1,202 @@
+/**
+ * Autonomous Refactor Tests (RFC-0092)
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	detectRefactorings,
+	assessRisk,
+	calculatePriority,
+	createPlan,
+	filterByRisk,
+	groupByFile,
+	groupByType,
+} from "../src/index.js";
+import type { RefactorFinding } from "../src/index.js";
+
+const makeFinding = (
+	overrides?: Partial<RefactorFinding>,
+): RefactorFinding => ({
+	id: `f${Math.random().toString(36).slice(2)}`,
+	type: "extract-method",
+	file: "src/test.ts",
+	location: { line: 10, column: 1 },
+	description: "Test finding",
+	risk: "low",
+	confidence: 0.7,
+	...overrides,
+});
+
+describe("detectRefactorings", () => {
+	it("detects magic literals", () => {
+		const files = [{ path: "src/test.ts", content: "const timeout = 5000;" }];
+		const findings = detectRefactorings(files);
+		expect(findings.some((f) => f.type === "replace-magic-literal")).toBe(true);
+	});
+
+	it("detects long functions", () => {
+		const lines = ["function longFunc() {"];
+		for (let i = 0; i < 38; i++) lines.push("  const x = " + i + ";");
+		lines.push("}");
+		const files = [{ path: "src/test.ts", content: lines.join("\n") }];
+		const findings = detectRefactorings(files);
+		expect(findings.some((f) => f.type === "extract-method")).toBe(true);
+	});
+
+	it("detects nested conditionals", () => {
+		const content = [
+			"if (a) {",
+			"  if (b) {",
+			"    if (c) {",
+			"      if (d) { console.log(1); }",
+			"    }",
+			"  }",
+			"}",
+		].join("\n");
+		const files = [{ path: "src/test.ts", content }];
+		const findings = detectRefactorings(files);
+		expect(findings.some((f) => f.type === "simplify-conditional")).toBe(true);
+	});
+
+	it("returns empty for clean code", () => {
+		const files = [
+			{
+				path: "src/test.ts",
+				content: "const x = 1;\nconst y = 2;\nconst sum = x + y;",
+			},
+		];
+		const findings = detectRefactorings(files);
+		expect(findings.length).toBeLessThanOrEqual(3);
+	});
+
+	it("limits magic literal findings per file", () => {
+		const lines = Array.from({ length: 20 }, (_, i) => `const val${i} = 999;`);
+		const files = [{ path: "src/test.ts", content: lines.join("\n") }];
+		const findings = detectRefactorings(files);
+		expect(
+			findings.filter((f) => f.type === "replace-magic-literal").length,
+		).toBeLessThanOrEqual(5);
+	});
+});
+
+describe("assessRisk", () => {
+	it("returns finding risk", () => {
+		expect(assessRisk(makeFinding({ risk: "high" }))).toBe("high");
+	});
+});
+
+describe("calculatePriority", () => {
+	it("higher for high-confidence", () => {
+		const high = makeFinding({ confidence: 0.9, risk: "low" });
+		const low = makeFinding({ confidence: 0.3, risk: "low" });
+		expect(calculatePriority(high)).toBeGreaterThan(calculatePriority(low));
+	});
+
+	it("higher for high-risk at same confidence", () => {
+		const critical = makeFinding({ confidence: 0.5, risk: "critical" });
+		const low = makeFinding({ confidence: 0.5, risk: "low" });
+		expect(calculatePriority(critical)).toBeGreaterThan(calculatePriority(low));
+	});
+
+	it("returns value between 0 and 1", () => {
+		const p = calculatePriority(
+			makeFinding({ confidence: 0.7, risk: "medium" }),
+		);
+		expect(p).toBeGreaterThanOrEqual(0);
+		expect(p).toBeLessThanOrEqual(1);
+	});
+});
+
+describe("createPlan", () => {
+	it("creates plan with findings", () => {
+		const findings = [makeFinding({ id: "f1" }), makeFinding({ id: "f2" })];
+		const plan = createPlan(findings);
+		expect(plan.findings).toHaveLength(2);
+		expect(plan.priorityOrder).toContain("f1");
+		expect(plan.priorityOrder).toContain("f2");
+	});
+
+	it("limits to maxFindings", () => {
+		const findings = Array.from({ length: 100 }, (_, i) =>
+			makeFinding({ id: `f${i}`, confidence: 1 - i / 100 }),
+		);
+		const plan = createPlan(findings, { maxFindings: 20 });
+		expect(plan.findings.length).toBeLessThanOrEqual(20);
+	});
+
+	it("filters by risk threshold", () => {
+		const findings = [
+			makeFinding({ id: "low", risk: "low" }),
+			makeFinding({ id: "high", risk: "high" }),
+			makeFinding({ id: "critical", risk: "critical" }),
+		];
+		const plan = createPlan(findings, { riskThreshold: "medium" });
+		expect(plan.findings.some((f) => f.id === "low")).toBe(true);
+		expect(plan.findings.some((f) => f.id === "high")).toBe(false);
+		expect(plan.findings.some((f) => f.id === "critical")).toBe(false);
+	});
+
+	it("includes blockers when preserveBehavior", () => {
+		const plan = createPlan([], { preserveBehavior: true });
+		expect(plan.blockers.length).toBeGreaterThan(0);
+	});
+
+	it("estimates positive impact", () => {
+		const findings = [
+			makeFinding({ risk: "medium" }),
+			makeFinding({ risk: "high" }),
+		];
+		const plan = createPlan(findings);
+		expect(plan.estimatedImpact.complexityReduction).toBeGreaterThan(0);
+	});
+});
+
+describe("filterByRisk", () => {
+	it("keeps low and medium when threshold is medium", () => {
+		const findings = [
+			makeFinding({ id: "low", risk: "low" }),
+			makeFinding({ id: "medium", risk: "medium" }),
+			makeFinding({ id: "high", risk: "high" }),
+		];
+		const filtered = filterByRisk(findings, "medium");
+		expect(filtered.map((f) => f.id)).toEqual(["low", "medium"]);
+	});
+
+	it("returns all when threshold is critical", () => {
+		const findings = [
+			makeFinding({ risk: "low" }),
+			makeFinding({ risk: "critical" }),
+		];
+		expect(filterByRisk(findings, "critical")).toHaveLength(2);
+	});
+});
+
+describe("groupByFile", () => {
+	it("groups findings by file", () => {
+		const findings = [
+			makeFinding({ id: "f1", file: "src/a.ts" }),
+			makeFinding({ id: "f2", file: "src/a.ts" }),
+			makeFinding({ id: "f3", file: "src/b.ts" }),
+		];
+		const groups = groupByFile(findings);
+		expect(groups.get("src/a.ts")).toHaveLength(2);
+		expect(groups.get("src/b.ts")).toHaveLength(1);
+	});
+
+	it("handles empty array", () => {
+		expect(groupByFile([]).size).toBe(0);
+	});
+});
+
+describe("groupByType", () => {
+	it("groups by type", () => {
+		const findings = [
+			makeFinding({ id: "f1", type: "extract-method" }),
+			makeFinding({ id: "f2", type: "extract-method" }),
+			makeFinding({ id: "f3", type: "rename-variable" }),
+		];
+		const groups = groupByType(findings);
+		expect(groups.get("extract-method")).toHaveLength(2);
+		expect(groups.get("rename-variable")).toHaveLength(1);
+	});
+});

package/packages/autonomous-runtime/README.md

@@ -0,0 +1,48 @@
+# Autonomous Runtime — RFC-0101
+
+Task Inbox, Task Lease, and worker supervision for autonomous post-session execution.
+
+## Package
+
+`@pi-harness/autonomous-runtime`
+
+## Concepts
+
+### Task Inbox
+
+Durable queue of tasks submitted by the harness master planner. Survives worker crashes, host reboots, and provider quota exhaustion.
+
+### Task Lease
+
+Atomic exclusive claim on a task. Guarantees **single-execution** under crash recovery. Other workers skip a leased task.
+
+### Worker
+
+Supervised process that reads from the inbox, claims tasks via leases, executes, and reports results.
+
+## Usage
+
+```ts
+import { TaskInbox, TaskLeaseManager, WORKER_ROOT } from "@pi-harness/autonomous-runtime";
+
+const inbox = new TaskInbox();
+const leaseMgr = new TaskLeaseManager();
+
+// Submit a task
+await inbox.submit({
+  title: "Fix login bug",
+  description: "Users cannot log in with SSO",
+  capability: "write",
+});
+
+// Worker: claim and work
+const task = await inbox.claimNext("worker-1", leaseMgr);
+if (task) {
+  // ... do work ...
+  await inbox.complete(task.id, { success: true });
+}
+```
+
+## Status
+
+**Phase 1 done.** Phases 2–10 pending implementation.

package/packages/autonomous-runtime/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pi/autonomous-runtime",
+  "version": "0.10.30",
+  "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
+  "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",
+    "test:watch": "bun test --watch",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "autonomous",
+    "runtime",
+    "task-queue",
+    "lease",
+    "worker",
+    "rfc-0101"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^7.0.2"
+  }
+}