pi-oxidized 0.1.1

package/.references/pi/packages/coding-agent/test/version-check.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	checkForNewPiVersion,
+	comparePackageVersions,
+	getLatestPiRelease,
+	getLatestPiVersion,
+	isNewerPackageVersion,
+} from "../src/utils/version-check.ts";
+
+const originalSkipVersionCheck = process.env.PI_SKIP_VERSION_CHECK;
+const originalOffline = process.env.PI_OFFLINE;
+
+afterEach(() => {
+	vi.unstubAllGlobals();
+	if (originalSkipVersionCheck === undefined) {
+		delete process.env.PI_SKIP_VERSION_CHECK;
+	} else {
+		process.env.PI_SKIP_VERSION_CHECK = originalSkipVersionCheck;
+	}
+	if (originalOffline === undefined) {
+		delete process.env.PI_OFFLINE;
+	} else {
+		process.env.PI_OFFLINE = originalOffline;
+	}
+});
+
+describe("version checks", () => {
+	it("compares package versions", () => {
+		expect(comparePackageVersions("0.70.6", "0.70.5")).toBeGreaterThan(0);
+		expect(comparePackageVersions("0.70.5", "0.70.5")).toBe(0);
+		expect(comparePackageVersions("0.70.4", "0.70.5")).toBeLessThan(0);
+		expect(comparePackageVersions("5.0.0-beta.20", "5.0.0-beta.9")).toBeGreaterThan(0);
+		expect(isNewerPackageVersion("0.70.5", "0.70.5")).toBe(false);
+		expect(isNewerPackageVersion("0.70.6", "0.70.5")).toBe(true);
+	});
+
+	it("returns only newer versions", async () => {
+		const fetchMock = vi.fn(async () => Response.json({ version: "1.2.3" }));
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(checkForNewPiVersion("1.2.3")).resolves.toBeUndefined();
+		await expect(checkForNewPiVersion("1.2.2")).resolves.toEqual({ version: "1.2.3" });
+	});
+
+	it("uses the pi.dev version check api with a pi user agent", async () => {
+		const fetchMock = vi.fn(async () => Response.json({ version: "1.2.4" }));
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(getLatestPiVersion("1.2.3")).resolves.toBe("1.2.4");
+		expect(fetchMock).toHaveBeenCalledWith(
+			"https://pi.dev/api/latest-version",
+			expect.objectContaining({
+				headers: expect.objectContaining({
+					"User-Agent": expect.stringMatching(/^pi\/1\.2\.3 /),
+					accept: "application/json",
+				}),
+			}),
+		);
+	});
+
+	it("returns the active package metadata from the version check api", async () => {
+		const fetchMock = vi.fn(async () =>
+			Response.json({
+				packageName: "@new-scope/pi",
+				version: "1.2.4",
+			}),
+		);
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(getLatestPiRelease("1.2.3")).resolves.toEqual({
+			packageName: "@new-scope/pi",
+			version: "1.2.4",
+		});
+	});
+
+	it("returns update notes from the version check api", async () => {
+		const fetchMock = vi.fn(async () => Response.json({ note: " **Read this** ", version: "1.2.4" }));
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(getLatestPiRelease("1.2.3")).resolves.toEqual({ note: "**Read this**", version: "1.2.4" });
+	});
+
+	it("skips api calls when version checks are disabled", async () => {
+		process.env.PI_SKIP_VERSION_CHECK = "1";
+		const fetchMock = vi.fn();
+		vi.stubGlobal("fetch", fetchMock);
+
+		await expect(getLatestPiVersion("1.2.3")).resolves.toBeUndefined();
+		expect(fetchMock).not.toHaveBeenCalled();
+	});
+});

package/.references/pi/packages/coding-agent/tsconfig.build.json

@@ -0,0 +1,17 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"paths": {
+			"@earendil-works/pi-agent-core": ["../agent/dist/index.d.ts"],
+			"@earendil-works/pi-agent-core/*": ["../agent/dist/*.d.ts"],
+			"@earendil-works/pi-ai": ["../ai/dist/index.d.ts"],
+			"@earendil-works/pi-ai/*": ["../ai/dist/*.d.ts", "../ai/dist/providers/*.d.ts"],
+			"@earendil-works/pi-tui": ["../tui/dist/index.d.ts"],
+			"@earendil-works/pi-tui/*": ["../tui/dist/*.d.ts", "../tui/dist/components/*.d.ts"]
+		},
+		"rootDir": "./src"
+	},
+	"include": ["src/**/*.ts", "src/**/*.d.ts"],
+	"exclude": ["node_modules", "dist"]
+}

package/.references/pi/packages/coding-agent/tsconfig.examples.json

@@ -0,0 +1,16 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"noEmit": true,
+		"paths": {
+			"@earendil-works/pi-coding-agent": ["./src/index.ts"],
+			"@earendil-works/pi-coding-agent/hooks": ["./src/core/hooks/index.ts"],
+			"@earendil-works/pi-tui": ["../tui/src/index.ts"],
+			"@earendil-works/pi-ai": ["../ai/src/index.ts"],
+			"typebox": ["../../node_modules/typebox"]
+		},
+		"skipLibCheck": true
+	},
+	"include": ["examples/**/*.ts"],
+	"exclude": ["node_modules", "dist"]
+}

package/.references/pi/packages/coding-agent/vitest.config.ts

@@ -0,0 +1,38 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+const aiSrcIndex = fileURLToPath(new URL("../ai/src/index.ts", import.meta.url));
+const aiSrcCompat = fileURLToPath(new URL("../ai/src/compat.ts", import.meta.url));
+const aiSrcOAuth = fileURLToPath(new URL("../ai/src/oauth.ts", import.meta.url));
+const aiSrcProviders = fileURLToPath(new URL("../ai/src/providers", import.meta.url));
+const agentSrcIndex = fileURLToPath(new URL("../agent/src/index.ts", import.meta.url));
+const tuiSrcIndex = fileURLToPath(new URL("../tui/src/index.ts", import.meta.url));
+
+export default defineConfig({
+	test: {
+		globals: true,
+		environment: "node",
+		testTimeout: 30000,
+		reporters: process.env.GITHUB_ACTIONS ? ["dot", "github-actions"] : ["dot"],
+		silent: "passed-only",
+		server: {
+			deps: {
+				external: [/@silvia-odwyer\/photon-node/],
+			},
+		},
+	},
+	resolve: {
+		alias: [
+			{ find: /^@earendil-works\/pi-ai$/, replacement: aiSrcIndex },
+			{ find: /^@earendil-works\/pi-ai\/compat$/, replacement: aiSrcCompat },
+			{ find: /^@earendil-works\/pi-ai\/oauth$/, replacement: aiSrcOAuth },
+			{ find: /^@earendil-works\/pi-ai\/providers\/(.+)$/, replacement: `${aiSrcProviders}/$1.ts` },
+			{ find: /^@earendil-works\/pi-agent-core$/, replacement: agentSrcIndex },
+			{ find: /^@earendil-works\/pi-tui$/, replacement: tuiSrcIndex },
+			{ find: /^@mariozechner\/pi-ai$/, replacement: aiSrcIndex },
+			{ find: /^@mariozechner\/pi-ai\/oauth$/, replacement: aiSrcOAuth },
+			{ find: /^@mariozechner\/pi-agent-core$/, replacement: agentSrcIndex },
+			{ find: /^@mariozechner\/pi-tui$/, replacement: tuiSrcIndex },
+		],
+	},
+});

package/.references/pi/packages/orchestrator/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.80.10] - 2026-07-16
+
+## [0.80.9] - 2026-07-16
+
+## [0.80.8] - 2026-07-16
+
+## [0.80.7] - 2026-07-14
+
+## [0.80.6] - 2026-07-09
+
+## [0.80.5] - 2026-07-09
+
+## [0.80.4] - 2026-07-09
+
+## [0.80.3] - 2026-06-30

package/.references/pi/packages/orchestrator/README.md

@@ -0,0 +1,11 @@
+# @earendil-works/pi-orchestrator
+
+Experimental. This package is under active development and may change or be removed without notice. Its CLI, APIs, and behavior are not yet stable.
+
+Orchestrator package for pi.
+
+## CLI
+
+```bash
+orchestrator --help
+```

package/.references/pi/packages/orchestrator/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@earendil-works/pi-orchestrator",
+	"version": "0.80.10",
+	"description": "experimental orchestrator package for pi",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"clean": "shx rm -rf dist",
+		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
+		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js",
+		"prepublishOnly": "npm run clean && npm run build"
+	},
+	"keywords": [
+		"pi",
+		"orchestrator"
+	],
+	"author": "Earendil Works",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/earendil-works/pi.git",
+		"directory": "packages/orchestrator"
+	},
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"dependencies": {
+		"@earendil-works/pi-coding-agent": "^0.80.10"
+	},
+	"devDependencies": {
+		"shx": "0.4.0"
+	}
+}

package/.references/pi/packages/orchestrator/src/cli.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { createConnection } from "node:net";
+import { dirname, join } from "node:path";
+import { cwd } from "node:process";
+import { fileURLToPath } from "node:url";
+import type { RpcCommand, RpcExtensionUIResponse } from "@earendil-works/pi-coding-agent";
+import { getSocketPath } from "./config.ts";
+import { sendIpcRequest } from "./ipc/client.ts";
+import { encodeMessage } from "./ipc/protocol.ts";
+import { serve } from "./serve.ts";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8")) as {
+	version: string;
+};
+
+function printHelp(): void {
+	console.log(
+		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator rpc-stream <instance-id>\n  orchestrator --help\n  orchestrator --version\n\nRPC stream stdin expects JSONL RpcCommand or extension_ui_response messages.`,
+	);
+}
+
+function printResponse(response: unknown): void {
+	console.log(JSON.stringify(response, null, 2));
+}
+
+function getFlagValue(args: string[], flag: string): string | undefined {
+	const index = args.indexOf(flag);
+	if (index === -1 || index + 1 >= args.length) {
+		return undefined;
+	}
+	return args[index + 1];
+}
+
+async function rpcStream(instanceId: string): Promise<void> {
+	const socket = createConnection(getSocketPath());
+	let stdinBuffer = "";
+	process.stdin.setEncoding("utf8");
+
+	await new Promise<void>((resolve, reject) => {
+		socket.once("connect", () => {
+			socket.write(encodeMessage({ type: "rpc_stream", instanceId }));
+			resolve();
+		});
+		socket.once("error", reject);
+	});
+
+	socket.on("data", (chunk: Buffer | string) => {
+		process.stdout.write(chunk.toString());
+	});
+	console.error(`connected to rpc stream ${instanceId}; send JSONL RpcCommand or extension_ui_response on stdin`);
+	socket.on("error", (error) => {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	});
+	socket.on("end", () => {
+		process.exit(0);
+	});
+	process.stdin.on("data", (chunk: string) => {
+		stdinBuffer += chunk;
+		while (true) {
+			const newlineIndex = stdinBuffer.indexOf("\n");
+			if (newlineIndex === -1) {
+				return;
+			}
+			const line = stdinBuffer.slice(0, newlineIndex).trim();
+			stdinBuffer = stdinBuffer.slice(newlineIndex + 1);
+			if (!line) {
+				continue;
+			}
+			const parsed = JSON.parse(line) as RpcCommand | RpcExtensionUIResponse;
+			socket.write(encodeMessage(parsed));
+		}
+	});
+}
+
+async function main(): Promise<void> {
+	const args = process.argv.slice(2);
+
+	if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+		printHelp();
+		process.exit(0);
+	}
+
+	if (args[0] === "--version" || args[0] === "-v") {
+		console.log(packageJson.version);
+		process.exit(0);
+	}
+
+	if (args[0] === "serve") {
+		await serve();
+		return;
+	}
+
+	if (args[0] === "list") {
+		printResponse(await sendIpcRequest({ type: "list" }));
+		return;
+	}
+
+	if (args[0] === "spawn") {
+		const spawnCwd = getFlagValue(args, "--cwd") ?? cwd();
+		const label = getFlagValue(args, "--label");
+		printResponse(await sendIpcRequest({ type: "spawn", cwd: spawnCwd, label }));
+		return;
+	}
+
+	if (args[0] === "status") {
+		const instanceId = args[1];
+		if (!instanceId) {
+			console.error("Usage: orchestrator status <instance-id>");
+			process.exit(1);
+		}
+		printResponse(await sendIpcRequest({ type: "status", instanceId }));
+		return;
+	}
+
+	if (args[0] === "stop") {
+		const instanceId = args[1];
+		if (!instanceId) {
+			console.error("Usage: orchestrator stop <instance-id>");
+			process.exit(1);
+		}
+		printResponse(await sendIpcRequest({ type: "stop", instanceId }));
+		return;
+	}
+
+	if (args[0] === "rpc") {
+		const instanceId = args[1];
+		const commandJson = args[2];
+		if (!instanceId || !commandJson) {
+			console.error("Usage: orchestrator rpc <instance-id> <json-command>");
+			process.exit(1);
+		}
+		printResponse(
+			await sendIpcRequest({
+				type: "rpc",
+				instanceId,
+				command: JSON.parse(commandJson),
+			}),
+		);
+		return;
+	}
+
+	if (args[0] === "rpc-stream") {
+		const instanceId = args[1];
+		if (!instanceId) {
+			console.error("Usage: orchestrator rpc-stream <instance-id>");
+			process.exit(1);
+		}
+		await rpcStream(instanceId);
+		return;
+	}
+
+	console.error(`Unknown command: ${args[0]}`);
+	printHelp();
+	process.exit(1);
+}
+
+await main();

package/.references/pi/packages/orchestrator/src/config.ts

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const CONFIG_DIR_NAME = ".pi";
+const ENV_ORCHESTRATOR_DIR = "PI_ORCHESTRATOR_DIR";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Detect if we're running as a Bun compiled binary.
+ * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
+ */
+export const isBunBinary =
+	import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
+
+interface PackageJson {
+	version?: string;
+}
+
+function getPackageJsonPath(): string {
+	let dir = __dirname;
+	while (dir !== dirname(dir)) {
+		const packageJsonPath = join(dir, "package.json");
+		if (existsSync(packageJsonPath)) {
+			return packageJsonPath;
+		}
+		dir = dirname(dir);
+	}
+	return join(__dirname, "package.json");
+}
+
+let pkg: PackageJson = {};
+try {
+	pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8")) as PackageJson;
+} catch (e: unknown) {
+	const err = e as NodeJS.ErrnoException;
+	if (err.code !== "ENOENT") throw e;
+}
+
+export const VERSION: string = pkg.version || "0.0.0";
+
+export function getOrchestratorDir(): string {
+	const envDir = process.env[ENV_ORCHESTRATOR_DIR];
+	if (envDir) {
+		return envDir;
+	}
+
+	const piDir = process.env.PI_CONFIG_DIR || join(homedir(), CONFIG_DIR_NAME);
+	return join(piDir, "orchestrator");
+}
+
+export function getAuthPath(): string {
+	return join(getOrchestratorDir(), "auth.json");
+}
+
+export function getMachinePath(): string {
+	return join(getOrchestratorDir(), "machine.json");
+}
+
+export function getInstancesPath(): string {
+	return join(getOrchestratorDir(), "instances.json");
+}
+
+export function getSocketPath(): string {
+	return join(getOrchestratorDir(), "orchestrator.sock");
+}

package/.references/pi/packages/orchestrator/src/handler.ts

@@ -0,0 +1,161 @@
+import type {
+	AgentSessionEvent,
+	RpcCommand,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+	RpcResponse,
+} from "@earendil-works/pi-coding-agent";
+import type {
+	ErrorResponse,
+	InstanceSummary,
+	ListRequest,
+	ListResponse,
+	OrchestratorRequest,
+	OrchestratorResponse,
+	RpcBridgeResponse,
+	RpcReadyResponse,
+	RpcRequest,
+	RpcStreamRequest,
+	SpawnRequest,
+	SpawnResponse,
+	StatusRequest,
+	StatusResponse,
+	StopRequest,
+	StopResponse,
+} from "./ipc/protocol.ts";
+import { supervisor } from "./supervisor.ts";
+import type { InstanceRecord } from "./types.ts";
+
+function toInstanceSummary(instance: InstanceRecord): InstanceSummary {
+	return {
+		id: instance.id,
+		status: instance.status,
+		cwd: instance.cwd,
+		label: instance.label,
+		sessionId: instance.sessionId,
+		sessionFile: instance.sessionFile,
+		radiusPiId: instance.radiusPiId,
+	};
+}
+
+function unknownInstanceError(instanceId: string): ErrorResponse {
+	return {
+		type: "error",
+		ok: false,
+		error: `Unknown instance: ${instanceId}`,
+	};
+}
+
+// Overhead types
+export async function handleIpcRequest(request: SpawnRequest): Promise<SpawnResponse | ErrorResponse>;
+export async function handleIpcRequest(request: ListRequest): Promise<ListResponse | ErrorResponse>;
+export async function handleIpcRequest(request: StopRequest): Promise<StopResponse | ErrorResponse>;
+export async function handleIpcRequest(request: StatusRequest): Promise<StatusResponse | ErrorResponse>;
+export async function handleIpcRequest(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse>;
+export async function handleIpcRequest(request: RpcStreamRequest): Promise<RpcReadyResponse | ErrorResponse>;
+export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse>;
+export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
+	switch (request.type) {
+		case "spawn": {
+			const instance = await supervisor.spawnInstance({
+				cwd: request.cwd,
+				label: request.label,
+			});
+			return {
+				type: "spawn_result",
+				ok: true,
+				instance: toInstanceSummary(instance),
+			};
+		}
+
+		case "list": {
+			return {
+				type: "list_result",
+				ok: true,
+				instances: supervisor.listInstances().map(toInstanceSummary),
+			};
+		}
+
+		case "status": {
+			const instance = supervisor.getInstance(request.instanceId);
+			if (!instance) {
+				return unknownInstanceError(request.instanceId);
+			}
+
+			return {
+				type: "status_result",
+				ok: true,
+				instance: toInstanceSummary(instance),
+			};
+		}
+
+		case "stop": {
+			const instance = await supervisor.stopInstance(request.instanceId);
+			if (!instance) {
+				return unknownInstanceError(request.instanceId);
+			}
+
+			return {
+				type: "stop_result",
+				ok: true,
+				instanceId: request.instanceId,
+			};
+		}
+
+		case "rpc": {
+			const response = await supervisor.handleRpc(request.instanceId, request.command);
+			if (!response) {
+				return unknownInstanceError(request.instanceId);
+			}
+
+			return {
+				type: "rpc_result",
+				ok: true,
+				response,
+			};
+		}
+
+		case "rpc_stream": {
+			const instance = supervisor.getInstance(request.instanceId);
+			if (!instance) {
+				return unknownInstanceError(request.instanceId);
+			}
+			return {
+				type: "rpc_ready",
+				ok: true,
+				instance: toInstanceSummary(instance),
+			};
+		}
+	}
+}
+
+export function openRpcStream(
+	instanceId: string,
+	onResponse: (response: RpcResponse) => void,
+	onSessionEvent: (event: AgentSessionEvent) => void,
+	onUiRequest: (request: RpcExtensionUIRequest) => void,
+):
+	| {
+			handleRequest(request: RpcCommand | RpcExtensionUIResponse): Promise<void>;
+			close(): void;
+	  }
+	| undefined {
+	const handle = supervisor.openRpcStream(instanceId, onSessionEvent, onUiRequest);
+	if (!handle) {
+		return undefined;
+	}
+
+	return {
+		async handleRequest(request): Promise<void> {
+			if (request.type === "extension_ui_response") {
+				handle.handleUiResponse(request);
+				return;
+			}
+			const response = await handle.handleRpc(request);
+			onResponse(response);
+		},
+		close(): void {
+			handle.close();
+		},
+	};
+}

package/.references/pi/packages/orchestrator/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./config.ts";
+export * from "./handler.ts";
+export * from "./ipc/client.ts";
+export * from "./ipc/protocol.ts";
+export * from "./ipc/server.ts";
+export * from "./rpc-process.ts";
+export * from "./serve.ts";
+export * from "./storage.ts";
+export * from "./supervisor.ts";
+export * from "./types.ts";