pi-harness-runtime 0.9.2 → 0.9.5

package/packages/a2a-adapter/src/transport.ts

@@ -0,0 +1,142 @@
+/**
+ * A2A Adapter — HTTP Transport (RFC-0069)
+ */
+
+import { wellKnownAgentUrl } from "./protocol.js";
+import type { AgentCard, A2AClientConfig, TaskHandle } from "./types.js";
+
+/**
+ * HTTP client for A2A protocol
+ */
+export class A2ATransport {
+	private baseUrl: string;
+	private config: A2AClientConfig;
+
+	constructor(baseUrl: string, config: A2AClientConfig = {}) {
+		this.baseUrl = baseUrl.replace(/\/$/, "");
+		this.config = config;
+	}
+
+	private async request<T>(
+		method: string,
+		path: string,
+		body?: unknown,
+	): Promise<T> {
+		const url = `${this.baseUrl}${path}`;
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			Accept: "application/json",
+			...this.config.headers,
+		};
+
+		const response = await fetch(url, {
+			method,
+			headers,
+			body: body ? JSON.stringify(body) : undefined,
+			signal: AbortSignal.timeout(this.config.timeout ?? 30000),
+		} as RequestInit);
+
+		if (!response.ok) {
+			throw new Error(
+				`A2A HTTP error: ${response.status} ${response.statusText}`,
+			);
+		}
+
+		return response.json() as Promise<T>;
+	}
+
+	/**
+	 * Fetch agent card from well-known endpoint
+	 */
+	async getAgentCard(): Promise<AgentCard> {
+		return this.request<AgentCard>("GET", "/.well-known/agent.json");
+	}
+
+	/**
+	 * Send a task message to an agent
+	 */
+	async sendTask(params: {
+		taskId?: string;
+		sessionId?: string;
+		message: { role: string; content: string };
+	}): Promise<TaskHandle> {
+		return this.request<TaskHandle>("POST", "/a2a/tasks/send", {
+			jsonrpc: "2.0",
+			method: "tasks/send",
+			params,
+		});
+	}
+
+	/**
+	 * Send task with streaming subscription
+	 */
+	async sendTaskSubscribe(params: {
+		taskId?: string;
+		sessionId?: string;
+		message: { role: string; content: string };
+	}): Promise<TaskHandle> {
+		return this.request<TaskHandle>("POST", "/a2a/tasks/sendSubscribe", {
+			jsonrpc: "2.0",
+			method: "tasks/sendSubscribe",
+			params,
+		});
+	}
+
+	/**
+	 * Get task status
+	 */
+	async getTask(taskId: string): Promise<unknown> {
+		return this.request("GET", `/a2a/tasks/${taskId}`);
+	}
+
+	/**
+	 * Cancel a task
+	 */
+	async cancelTask(
+		taskId: string,
+	): Promise<{ taskId: string; status: string }> {
+		return this.request("POST", `/a2a/tasks/${taskId}/cancel`);
+	}
+
+	/**
+	 * SSE stream for task updates
+	 */
+	async *streamTaskUpdates(taskId: string): AsyncGenerator<unknown> {
+		const url = `${this.baseUrl}/a2a/tasks/${taskId}/stream`;
+		const response = await fetch(url, {
+			headers: {
+				Accept: "text/event-stream",
+				...this.config.headers,
+			},
+			signal: AbortSignal.timeout(this.config.timeout ?? 60000),
+		} as RequestInit);
+
+		if (!response.ok || !response.body) {
+			throw new Error(`Stream error: ${response.status}`);
+		}
+
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() ?? "";
+
+				for (const line of lines) {
+					if (line.startsWith("data: ")) {
+						const data = JSON.parse(line.slice(6));
+						yield data;
+					}
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+	}
+}

package/packages/a2a-adapter/src/types.ts

@@ -0,0 +1,117 @@
+/**
+ * A2A Adapter — Types (RFC-0069)
+ */
+
+// ─── Agent Card ─────────────────────────────────────────────────────────────
+
+export interface AgentCard {
+	name: string;
+	description: string;
+	url: string;
+	version: string;
+	capabilities: AgentCapabilities;
+	skills: Skill[];
+	authentication?: Authentication;
+	defaultInputModes?: string[];
+	defaultOutputModes?: string[];
+}
+
+export interface AgentCapabilities {
+	streaming?: boolean;
+	pushNotifications?: boolean;
+	stateTransitionHistory?: boolean;
+}
+
+export interface Skill {
+	id: string;
+	name: string;
+	description: string;
+	tags?: string[];
+	inputModes?: string[];
+	outputModes?: string[];
+}
+
+export interface Authentication {
+	schemes: string[];
+	credentials?: string;
+}
+
+// ─── Task ─────────────────────────────────────────────────────────────────
+
+export type TaskStatus =
+	| "submitted"
+	| "working"
+	| "completed"
+	| "canceled"
+	| "failed";
+
+export interface Task {
+	id: string;
+	sessionId?: string;
+	status: TaskStatus;
+	artifacts?: Artifact[];
+	kind: "message" | "search" | "task";
+}
+
+export interface TaskStatusUpdateEvent {
+	taskId: string;
+	status: TaskStatus;
+	message?: TaskMessage;
+	final?: boolean;
+}
+
+export interface TaskMessage {
+	role: "agent" | "user";
+	content: string;
+}
+
+export interface Artifact {
+	name?: string;
+	description?: string;
+	parts: Array<{ type: "text"; text: string }>;
+}
+
+// ─── A2A Requests / Responses ─────────────────────────────────────────────
+
+export type A2ARequest =
+	| {
+			method: "tasks/send";
+			params: { taskId?: string; sessionId?: string; message: TaskMessage };
+	  }
+	| {
+			method: "tasks/sendSubscribe";
+			params: { taskId?: string; sessionId?: string; message: TaskMessage };
+	  }
+	| { method: "tasks/get"; params: { taskId: string } }
+	| { method: "tasks/cancel"; params: { taskId: string } }
+	| { method: "agents/info"; params: { agentId?: string } }
+	| { method: "agents/list"; params?: { filter?: Record<string, string> } };
+
+export interface A2AResponse {
+	result?: unknown;
+	error?: { code: number; message: string };
+}
+
+// ─── A2A Client ─────────────────────────────────────────────────────────
+
+export interface A2AClientConfig {
+	timeout?: number;
+	headers?: Record<string, string>;
+}
+
+export interface TaskHandle {
+	taskId: string;
+	status: TaskStatus;
+}
+
+// ─── A2A Agent ───────────────────────────────────────────────────────────
+
+export interface A2AAgentConfig {
+	name: string;
+	description: string;
+	url: string;
+	version: string;
+	skills?: Skill[];
+	capabilities?: Partial<AgentCapabilities>;
+	port?: number;
+}

package/packages/a2a-adapter/test/a2a.test.ts

@@ -0,0 +1,151 @@
+/**
+ * A2A Adapter Tests (RFC-0069)
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	createAgentCard,
+	routeTask,
+	getTask,
+	cancelTask,
+	taskStatusUpdateSSE,
+} from "../src/agent.js";
+import { A2AClient } from "../src/client.js";
+import { A2ATransport } from "../src/transport.js";
+import {
+	A2A_PROTOCOL_VERSION,
+	WELL_KNOWN_AGENT_PATH,
+} from "../src/protocol.js";
+import type { TaskMessage } from "../src/types.js";
+
+describe("A2A Protocol Constants", () => {
+	it("exports protocol version", () => {
+		expect(A2A_PROTOCOL_VERSION).toBe("1.0.0");
+	});
+
+	it("exports well-known agent path", () => {
+		expect(WELL_KNOWN_AGENT_PATH).toBe("/.well-known/agent.json");
+	});
+});
+
+describe("AgentCard", () => {
+	it("creates agent card with defaults", () => {
+		const card = createAgentCard({
+			name: "pi-harness",
+			description: "AI coding harness",
+			url: "http://localhost:3000",
+			version: "0.9.4",
+		});
+		expect(card.name).toBe("pi-harness");
+		expect(card.capabilities.streaming).toBe(true);
+		expect(card.skills.length).toBeGreaterThan(0);
+		expect(card.skills[0].id).toBe("code-analysis");
+	});
+
+	it("creates agent card with custom skills", () => {
+		const card = createAgentCard({
+			name: "test-agent",
+			description: "Test",
+			url: "http://localhost:3001",
+			version: "1.0.0",
+			skills: [
+				{
+					id: "custom",
+					name: "Custom",
+					description: "Custom skill",
+					tags: ["test"],
+				},
+			],
+		});
+		expect(card.skills).toHaveLength(1);
+		expect(card.skills[0].id).toBe("custom");
+	});
+
+	it("merges custom capabilities", () => {
+		const card = createAgentCard({
+			name: "test",
+			description: "Test",
+			url: "http://localhost:3002",
+			version: "1.0.0",
+			capabilities: { pushNotifications: true },
+		});
+		expect(card.capabilities.streaming).toBe(true);
+		expect(card.capabilities.pushNotifications).toBe(true);
+	});
+});
+
+describe("Task Routing", () => {
+	it("routes a task message", async () => {
+		const message: TaskMessage = { role: "user", content: "Analyze this code" };
+		const task = await routeTask(message);
+		expect(task.id).toMatch(/^task-/);
+		expect(task.status).toBe("completed");
+		expect(task.artifacts).toHaveLength(1);
+		expect(task.artifacts![0].parts[0].text).toContain("Analyze this code");
+	});
+
+	it("stores and retrieves task", async () => {
+		const message: TaskMessage = { role: "user", content: "Test" };
+		const task = await routeTask(message);
+		const retrieved = getTask(task.id);
+		expect(retrieved).not.toBeNull();
+		expect(retrieved!.id).toBe(task.id);
+	});
+
+	it("returns null for unknown task", () => {
+		expect(getTask("nonexistent-task")).toBeNull();
+	});
+
+	it("cancels a task", async () => {
+		const message: TaskMessage = { role: "user", content: "Cancel test" };
+		const task = await routeTask(message);
+		expect(task.status).toBe("completed");
+		const result = cancelTask(task.id);
+		expect(result).toBe(true);
+		expect(getTask(task.id)!.status).toBe("canceled");
+	});
+
+	it("returns false when canceling unknown task", () => {
+		expect(cancelTask("nonexistent")).toBe(false);
+	});
+
+	it("generates SSE status update", async () => {
+		const message: TaskMessage = { role: "user", content: "SSE test" };
+		const task = await routeTask(message);
+		const sse = taskStatusUpdateSSE(task.id);
+		expect(sse).toContain("task_status_update");
+		expect(sse).toContain(task.id);
+		expect(sse).toContain("completed");
+		expect(sse).toContain("final");
+	});
+});
+
+describe("A2AClient", () => {
+	it("creates client with URL", () => {
+		const client = new A2AClient("http://localhost:3000");
+		expect(client).toBeDefined();
+	});
+
+	it("sendTask throws on unreachable server", async () => {
+		const client = new A2AClient("http://localhost:9999");
+		await expect(client.sendTask("test")).rejects.toThrow();
+	});
+
+	it("findAgents returns empty array", async () => {
+		const client = new A2AClient("http://localhost:3000");
+		const results = await client.findAgents({ skill: "test" });
+		expect(results).toEqual([]);
+	});
+});
+
+describe("A2ATransport", () => {
+	it("creates transport with config", () => {
+		const t = new A2ATransport("http://localhost:3000", { timeout: 5000 });
+		expect(t).toBeDefined();
+	});
+
+	it("getAgentCard throws on invalid URL", async () => {
+		const t = new A2ATransport("http://localhost:9999", { timeout: 2000 });
+		await expect(t.getAgentCard()).rejects.toThrow();
+	});
+});

package/packages/a2a-adapter/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "./dist", "rootDir": "./src" },
+  "include": ["src/**/*"]
+}

package/packages/auth/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/auth",
+  "version": "0.9.5",
+  "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/dist/detector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Autonomous Refactor — Pattern Detection (RFC-0092)
+ */
+import type { RefactorFinding, RiskLevel } from "./types.js";
+export declare function detectRefactorings(files: Array<{
+    path: string;
+    content: string;
+}>): RefactorFinding[];
+export declare function assessRisk(finding: RefactorFinding): RiskLevel;
+export declare function calculatePriority(finding: RefactorFinding): number;
+//# sourceMappingURL=detector.d.ts.map

package/packages/autonomous-refactor/dist/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../src/detector.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI7D,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7C,eAAe,EAAE,CAWnB;AAqLD,wBAAgB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,SAAS,CAE9D;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAYlE"}