@pstdio/pocketcoder-remote 0.2.0 → 0.2.1

package/package.json

@@ -6,7 +6,7 @@
 			"type:app"
 		]
 	},
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"private": false,
 	"description": "Pi-based terminal UI for PocketCoder workspaces.",
 	"type": "module",
@@ -18,8 +18,6 @@
 	},
 	"files": [
 		"dist",
-		"src",
-		"!src/**/*.test.ts",
 		"README.md",
 		"LICENSE"
 	],
@@ -33,18 +31,18 @@
 		"node": ">=22.19.0"
 	},
 	"scripts": {
-		"build": "bun build ./src/bin.ts --outdir ./dist --target node",
+		"build": "bun build ./src/bin.ts ./src/extension.ts --outdir ./dist --target node --external '@earendil-works/*'",
 		"start": "bun ./src/bin.ts",
 		"test": "bun test",
 		"typecheck": "tsc --project ./tsconfig.json --noEmit"
 	},
 	"dependencies": {
-		"@pstdio/pocketcoder-client": "workspace:*",
 		"@earendil-works/pi-ai": "0.83.0",
 		"@earendil-works/pi-coding-agent": "0.83.0",
 		"@earendil-works/pi-tui": "0.83.0"
 	},
 	"devDependencies": {
+		"@pstdio/pocketcoder-client": "workspace:*",
 		"@types/bun": "1.3.14",
 		"typescript": "5.9.3"
 	}

package/src/agentapi-events.ts

@@ -1,104 +0,0 @@
-interface MessageUpdate {
-	event: "message_update";
-	data: {
-		id: number;
-		message: string;
-		role: string;
-		time?: string;
-	};
-}
-
-interface StatusChange {
-	event: "status_change";
-	data: {
-		agent_type?: string;
-		status: "running" | "stable";
-	};
-}
-
-interface AgentError {
-	event: "agent_error";
-	data: {
-		level?: string;
-		message: string;
-		time?: string;
-	};
-}
-
-export type AgentApiEvent = MessageUpdate | StatusChange | AgentError;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}
-
-function eventPayload(block: string): { event: string; parsed: Record<string, unknown> } | null {
-	let event = "message";
-	const data: string[] = [];
-	for (const line of block.split("\n")) {
-		if (line.startsWith(":")) continue;
-		const separator = line.indexOf(":");
-		const field = separator === -1 ? line : line.slice(0, separator);
-		const value = separator === -1 ? "" : line.slice(separator + 1).replace(/^ /, "");
-		if (field === "event") event = value;
-		if (field === "data") data.push(value);
-	}
-	if (data.length === 0) return null;
-	try {
-		const parsed = JSON.parse(data.join("\n")) as unknown;
-		return isRecord(parsed) ? { event, parsed } : null;
-	} catch {
-		return null;
-	}
-}
-
-function parseEvent(block: string): AgentApiEvent | null {
-	const payload = eventPayload(block);
-	if (!payload) return null;
-	const { event, parsed } = payload;
-	if (
-		event === "message_update" &&
-		typeof parsed.id === "number" &&
-		typeof parsed.message === "string" &&
-		typeof parsed.role === "string"
-	) {
-		return { event, data: parsed as MessageUpdate["data"] };
-	}
-	if (event === "status_change" && (parsed.status === "running" || parsed.status === "stable")) {
-		return { event, data: parsed as StatusChange["data"] };
-	}
-	if (event === "agent_error" && typeof parsed.message === "string") {
-		return { event, data: parsed as AgentError["data"] };
-	}
-	return null;
-}
-
-export async function* readAgentApiEvents(
-	body: ReadableStream<Uint8Array>,
-	signal: AbortSignal,
-): AsyncGenerator<AgentApiEvent> {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = "";
-	const abort = () => {
-		void reader.cancel(signal.reason).catch(() => {});
-	};
-	if (signal.aborted) abort();
-	else signal.addEventListener("abort", abort, { once: true });
-	try {
-		while (!signal.aborted) {
-			const next = await reader.read();
-			if (next.done) break;
-			buffer = `${buffer}${decoder.decode(next.value, { stream: true })}`.replaceAll("\r\n", "\n");
-			let boundary = buffer.indexOf("\n\n");
-			while (boundary >= 0) {
-				const event = parseEvent(buffer.slice(0, boundary));
-				buffer = buffer.slice(boundary + 2);
-				if (event) yield event;
-				boundary = buffer.indexOf("\n\n");
-			}
-		}
-	} finally {
-		signal.removeEventListener("abort", abort);
-		reader.releaseLock();
-	}
-}

package/src/attachments.ts

@@ -1,158 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import { basename, extname, isAbsolute, resolve } from "node:path";
-import type { Context } from "@earendil-works/pi-ai";
-import type { CommandContext, CommandRegistrar } from "./commands";
-import type { ControlPlaneClient } from "./control-plane";
-import type { TargetRef } from "./session-target";
-
-// Turn-level attachment capture for the Pi remote: pasted images, explicit
-// @path tokens, and the /attach queue all upload through the PocketCoder
-// attachment API before the message referencing them is sent.
-
-export const DIRECT_MODE_ATTACHMENT_ERROR =
-	"file attachments need the PocketCoder workspace API; a direct AgentAPI URL (POCKETCODER_AGENTAPI_URL) cannot accept managed uploads";
-
-export interface TurnFile {
-	name: string;
-	mediaType: string;
-	bytes: Uint8Array;
-	localPath?: string;
-}
-
-const IMAGE_EXTENSIONS: Record<string, string> = {
-	"image/gif": "gif",
-	"image/jpeg": "jpg",
-	"image/png": "png",
-	"image/svg+xml": "svg",
-	"image/webp": "webp",
-};
-
-const MEDIA_TYPES: Record<string, string> = {
-	".csv": "text/csv",
-	".gif": "image/gif",
-	".html": "text/html",
-	".jpeg": "image/jpeg",
-	".jpg": "image/jpeg",
-	".json": "application/json",
-	".md": "text/markdown",
-	".pdf": "application/pdf",
-	".png": "image/png",
-	".svg": "image/svg+xml",
-	".txt": "text/plain",
-	".webp": "image/webp",
-};
-
-function lastUserContent(context: Context): Context["messages"][number]["content"] | undefined {
-	const message = context.messages.findLast((candidate) => candidate.role === "user");
-	return message?.role === "user" ? message.content : undefined;
-}
-
-export function userTextOf(context: Context): string {
-	const content = lastUserContent(context);
-	if (content === undefined) throw new Error("local Pi did not provide a user message");
-	if (typeof content === "string") return content;
-	return content
-		.filter((part) => part.type === "text")
-		.map((part) => part.text)
-		.join("\n");
-}
-
-function imageParts(context: Context): TurnFile[] {
-	const content = lastUserContent(context);
-	if (content === undefined || typeof content === "string") return [];
-	return content
-		.filter((part) => part.type === "image")
-		.map((part) => ({
-			name: `pasted-image.${IMAGE_EXTENSIONS[part.mimeType] ?? "bin"}`,
-			mediaType: part.mimeType,
-			bytes: Uint8Array.from(Buffer.from(part.data, "base64")),
-		}));
-}
-
-// Explicit `@path` tokens that resolve to a local regular file; quoted forms
-// (`@"my file.pdf"`) support spaces.
-export function pathTokens(text: string, cwd = process.cwd()): string[] {
-	const paths: string[] = [];
-	for (const match of text.matchAll(/@(?:"([^"]+)"|(\S+))/g)) {
-		const token = (match[1] ?? match[2]) as string;
-		const path = isAbsolute(token) ? token : resolve(cwd, token);
-		if (isFile(path) && !paths.includes(path)) paths.push(path);
-	}
-	return paths;
-}
-
-function isFile(path: string): boolean {
-	try {
-		return statSync(path).isFile();
-	} catch {
-		return false;
-	}
-}
-
-function fileFromPath(path: string): TurnFile {
-	return {
-		name: basename(path),
-		mediaType: MEDIA_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream",
-		bytes: new Uint8Array(readFileSync(path)),
-		localPath: path,
-	};
-}
-
-export function collectTurnFiles(context: Context, queue: string[], cwd?: string): TurnFile[] {
-	const text = userTextOf(context);
-	const paths = [...queue];
-	for (const path of pathTokens(text, cwd)) {
-		if (!paths.includes(path)) paths.push(path);
-	}
-	return [...imageParts(context), ...paths.map(fileFromPath)];
-}
-
-export async function uploadTurnFiles(
-	controlPlane: ControlPlaneClient,
-	workspaceId: string,
-	files: TurnFile[],
-): Promise<string[]> {
-	const ids: string[] = [];
-	for (const file of files) {
-		const uploaded = await controlPlane.attachments.upload(workspaceId, {
-			name: file.name,
-			mediaType: file.mediaType,
-			body: file.bytes,
-			sizeBytes: file.bytes.byteLength,
-		});
-		ids.push(uploaded.id);
-	}
-	return ids;
-}
-
-export interface AttachCommandDeps {
-	targets: TargetRef;
-	queue: string[];
-}
-
-export function registerAttachCommand(pi: CommandRegistrar, deps: AttachCommandDeps): void {
-	pi.registerCommand("attach", {
-		description: "Queue a local file to upload with the next message",
-		handler: async (args, ctx: CommandContext) => {
-			if (deps.targets.current.mode === "direct") {
-				ctx.ui.notify(DIRECT_MODE_ATTACHMENT_ERROR, "warning");
-				return;
-			}
-			const token = args.trim();
-			if (!token) {
-				ctx.ui.notify("usage: /attach <path>", "info");
-				return;
-			}
-			const path = isAbsolute(token) ? token : resolve(process.cwd(), token);
-			if (!isFile(path)) {
-				ctx.ui.notify(`no such file: ${token}`, "warning");
-				return;
-			}
-			deps.queue.push(path);
-			ctx.ui.notify(
-				`queued ${basename(path)} (${deps.queue.length} attachment${deps.queue.length === 1 ? "" : "s"})`,
-				"info",
-			);
-		},
-	});
-}

package/src/bin.ts

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { resolvePiInvocation } from "./launch";
-
-function main(): void {
-	let invocation: ReturnType<typeof resolvePiInvocation>;
-	try {
-		invocation = resolvePiInvocation({ argv: process.argv.slice(2) });
-	} catch (error) {
-		console.error(`pocketcoder-remote: ${error instanceof Error ? error.message : String(error)}`);
-		process.exit(1);
-	}
-	const child = spawn(invocation.command, invocation.args, {
-		stdio: "inherit",
-		env: invocation.env,
-	});
-	child.on("error", (error) => {
-		console.error(`pocketcoder-remote: failed to launch pi: ${error.message}`);
-		process.exit(1);
-	});
-	child.on("exit", (code, signal) => {
-		process.exit(code ?? (signal ? 1 : 0));
-	});
-}
-
-main();

package/src/client.ts

@@ -1,344 +0,0 @@
-import { type AgentApiEvent, readAgentApiEvents } from "./agentapi-events";
-
-export interface AgentApiMessage {
-	id: number;
-	content: string;
-	role: string;
-}
-
-export interface RemoteAgentClientConfig {
-	serviceUrl: string;
-	key: string;
-	pollIntervalMs?: number;
-	timeoutMs?: number;
-}
-
-interface AgentApiStatus {
-	status?: string;
-}
-
-interface AgentApiMessages {
-	messages?: unknown;
-}
-
-interface WorkspaceChange {
-	cursor?: unknown;
-	workspace?: {
-		agent_state?: unknown;
-	};
-}
-
-type FetchLike = typeof fetch;
-type SnapshotCallback = (snapshot: string) => void;
-
-function delay(ms: number, signal?: AbortSignal): Promise<void> {
-	return new Promise((resolve, reject) => {
-		const onAbort = () => {
-			clearTimeout(timeout);
-			reject(signal?.reason ?? new Error("remote request aborted"));
-		};
-		const timeout = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		if (signal?.aborted) {
-			onAbort();
-			return;
-		}
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}
-
-function parseMessages(value: unknown): AgentApiMessage[] {
-	const items = isRecord(value) && Array.isArray(value.messages) ? value.messages : [];
-	return items.flatMap((item) => {
-		if (
-			!isRecord(item) ||
-			typeof item.id !== "number" ||
-			typeof item.content !== "string" ||
-			typeof item.role !== "string"
-		) {
-			return [];
-		}
-		return [{ id: item.id, content: item.content, role: item.role }];
-	});
-}
-
-function isAgentMessage(message: AgentApiMessage): boolean {
-	return message.role === "agent" || message.role === "assistant";
-}
-
-function changesUrlFor(serviceUrl: string): string | undefined {
-	const url = new URL(serviceUrl);
-	const match = url.pathname.match(/^(.*\/v1\/workspaces\/[^/]+)\/(?:agent|services\/agent)$/);
-	if (!match) return undefined;
-	url.pathname = `${match[1]}/changes`;
-	url.search = "";
-	url.hash = "";
-	return url.toString();
-}
-
-async function responseError(response: Response): Promise<string> {
-	const body = (await response.text()).trim();
-	return body ? `${response.status} ${body.slice(0, 1000)}` : String(response.status);
-}
-
-export class RemoteAgentClient {
-	readonly serviceUrl: string;
-	readonly key: string;
-	readonly pollIntervalMs: number;
-	readonly timeoutMs: number;
-	readonly fetchImpl: FetchLike;
-	private changesUrl: string | undefined;
-
-	constructor(config: RemoteAgentClientConfig, fetchImpl: FetchLike = fetch) {
-		this.serviceUrl = config.serviceUrl.replace(/\/$/, "");
-		this.key = config.key;
-		this.pollIntervalMs = config.pollIntervalMs ?? 250;
-		this.timeoutMs = config.timeoutMs ?? 600_000;
-		this.fetchImpl = fetchImpl;
-		this.changesUrl = changesUrlFor(this.serviceUrl);
-	}
-
-	private async request(path: string, init: RequestInit = {}): Promise<Response> {
-		return await this.fetchImpl(`${this.serviceUrl}${path}`, {
-			...init,
-			headers: {
-				authorization: `Bearer ${this.key}`,
-				...(init.body ? { "content-type": "application/json" } : {}),
-				...(init.headers ?? {}),
-			},
-		});
-	}
-
-	private async messages(signal?: AbortSignal): Promise<AgentApiMessage[]> {
-		const response = await this.request("/messages", { signal });
-		if (!response.ok) {
-			throw new Error(`AgentAPI messages request failed: ${await responseError(response)}`);
-		}
-		return parseMessages((await response.json()) as AgentApiMessages);
-	}
-
-	private async status(signal?: AbortSignal): Promise<string> {
-		const response = await this.request("/status", { signal });
-		if (!response.ok) {
-			throw new Error(`AgentAPI status request failed: ${await responseError(response)}`);
-		}
-		const body = (await response.json()) as AgentApiStatus;
-		if (body.status !== "running" && body.status !== "stable") {
-			throw new Error(`AgentAPI returned an unknown status: ${JSON.stringify(body.status)}`);
-		}
-		return body.status;
-	}
-
-	private async eventStream(signal: AbortSignal): Promise<Response | null> {
-		const response = await this.request("/events", {
-			headers: { accept: "text/event-stream" },
-			signal,
-		});
-		if ([404, 409, 422].includes(response.status)) return null;
-		if (!response.ok) {
-			throw new Error(`AgentAPI events request failed: ${await responseError(response)}`);
-		}
-		if (!response.body) throw new Error("AgentAPI events response had no body");
-		return response;
-	}
-
-	private async workspaceChange(
-		after: number,
-		waitSeconds: number,
-		signal?: AbortSignal,
-	): Promise<{ cursor: number; agentState: string } | undefined> {
-		if (!this.changesUrl) return undefined;
-		const url = new URL(this.changesUrl);
-		url.searchParams.set("after", String(after));
-		url.searchParams.set("wait", String(waitSeconds));
-		const response = await this.fetchImpl(url, {
-			headers: { authorization: `Bearer ${this.key}` },
-			signal,
-		});
-		if (response.status === 404) {
-			this.changesUrl = undefined;
-			return undefined;
-		}
-		if (!response.ok) {
-			throw new Error(`PocketCoder changes request failed: ${await responseError(response)}`);
-		}
-		const body = (await response.json()) as WorkspaceChange;
-		if (
-			typeof body.cursor !== "number" ||
-			!isRecord(body.workspace) ||
-			(body.workspace.agent_state !== "unknown" &&
-				body.workspace.agent_state !== "running" &&
-				body.workspace.agent_state !== "stable")
-		) {
-			throw new Error("PocketCoder changes response was malformed");
-		}
-		return { cursor: body.cursor, agentState: body.workspace.agent_state };
-	}
-
-	private async submit(
-		prompt: string,
-		attachmentIds: string[],
-		signal: AbortSignal,
-	): Promise<void> {
-		const response = await this.request("/message", {
-			method: "POST",
-			body: JSON.stringify({
-				content: prompt,
-				type: "user",
-				...(attachmentIds.length > 0 ? { attachment_ids: attachmentIds } : {}),
-			}),
-			signal,
-		});
-		if (!response.ok) {
-			throw new Error(`AgentAPI message request failed: ${await responseError(response)}`);
-		}
-	}
-
-	private async pollForReply(
-		baselineId: number,
-		changeCursor: number,
-		deadline: number,
-		signal: AbortSignal,
-	): Promise<string> {
-		while (Date.now() < deadline) {
-			const remainingMs = deadline - Date.now();
-			const change = await this.workspaceChange(
-				changeCursor,
-				Math.max(1, Math.min(30, Math.ceil(remainingMs / 1000))),
-				signal,
-			);
-			if (change) changeCursor = change.cursor;
-			const [status, messages] = change
-				? [change.agentState, await this.messages(signal)]
-				: await Promise.all([this.status(signal), this.messages(signal)]);
-			const reply = messages
-				.filter((message) => message.id > baselineId && isAgentMessage(message))
-				.at(-1);
-			if (status === "stable" && reply?.content.trim()) return reply.content;
-			if (!change) await delay(this.pollIntervalMs, signal);
-		}
-		throw new Error(`remote agent did not finish within ${this.timeoutMs}ms`);
-	}
-
-	private async consumeEvents(
-		initial: Response,
-		onEvent: (event: AgentApiEvent) => Promise<void>,
-		signal: AbortSignal,
-	): Promise<"fallback" | "aborted"> {
-		let response = initial;
-		while (!signal.aborted) {
-			try {
-				if (!response.body) throw new Error("AgentAPI events response had no body");
-				for await (const event of readAgentApiEvents(response.body, signal)) {
-					await onEvent(event);
-				}
-			} catch {
-				if (signal.aborted) return "aborted";
-			}
-			if (signal.aborted) return "aborted";
-			await delay(this.pollIntervalMs, signal);
-			try {
-				const reconnected = await this.eventStream(signal);
-				if (!reconnected) return "fallback";
-				response = reconnected;
-			} catch {
-				if (signal.aborted) return "aborted";
-			}
-		}
-		return "aborted";
-	}
-
-	async send(
-		prompt: string,
-		signal?: AbortSignal,
-		attachmentIds: string[] = [],
-		onSnapshot?: SnapshotCallback,
-	): Promise<string> {
-		const timeout = new AbortController();
-		const timer = setTimeout(
-			() => timeout.abort(new Error(`remote agent did not finish within ${this.timeoutMs}ms`)),
-			this.timeoutMs,
-		);
-		const turnSignal = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
-		const stopEvents = new AbortController();
-		const eventSignal = AbortSignal.any([turnSignal, stopEvents.signal]);
-		try {
-			const before = await this.messages(turnSignal);
-			const baselineId = before.reduce((maximum, message) => Math.max(maximum, message.id), -1);
-			const baselineChange = await this.workspaceChange(0, 0, turnSignal);
-			const deadline = Date.now() + this.timeoutMs;
-			const initialEvents = await this.eventStream(eventSignal);
-			if (!initialEvents) {
-				await this.submit(prompt, attachmentIds, turnSignal);
-				return await this.pollForReply(
-					baselineId,
-					baselineChange?.cursor ?? 0,
-					deadline,
-					turnSignal,
-				);
-			}
-
-			let submitted = false;
-			let lastSnapshot = "";
-			let complete!: (value: string) => void;
-			const completed = new Promise<string>((resolve) => {
-				complete = resolve;
-			});
-			const consume = this.consumeEvents(
-				initialEvents,
-				async (event) => {
-					if (
-						event.event === "message_update" &&
-						event.data.id > baselineId &&
-						(event.data.role === "agent" || event.data.role === "assistant") &&
-						event.data.message.trim() &&
-						event.data.message !== lastSnapshot
-					) {
-						lastSnapshot = event.data.message;
-						onSnapshot?.(lastSnapshot);
-					}
-					if (event.event !== "status_change" || event.data.status !== "stable" || !submitted) {
-						return;
-					}
-					const final = (await this.messages(turnSignal))
-						.filter((message) => message.id > baselineId && isAgentMessage(message))
-						.at(-1);
-					if (!final?.content.trim()) return;
-					if (final.content !== lastSnapshot) onSnapshot?.(final.content);
-					complete(final.content);
-				},
-				eventSignal,
-			);
-			submitted = true;
-			await this.submit(prompt, attachmentIds, turnSignal);
-			const outcome = await Promise.race([
-				completed.then((value) => ({ kind: "complete" as const, value })),
-				consume.then((result) => ({ kind: result })),
-			]);
-			if (outcome.kind === "complete") return outcome.value;
-			if (outcome.kind === "fallback") {
-				return await this.pollForReply(
-					baselineId,
-					baselineChange?.cursor ?? 0,
-					deadline,
-					turnSignal,
-				);
-			}
-			throw turnSignal.reason ?? new Error("remote request aborted");
-		} catch (error) {
-			if (timeout.signal.aborted) throw timeout.signal.reason;
-			throw error;
-		} finally {
-			clearTimeout(timer);
-			stopEvents.abort("turn ended");
-		}
-	}
-}
-
-export { serviceUrlFromEnvironment } from "./environment";