@pstdio/pocketcoder-remote 0.2.0 → 0.2.1

package/src/response-stream.ts

@@ -1,43 +0,0 @@
-import type { AssistantMessage, AssistantMessageEventStream } from "@earendil-works/pi-ai";
-
-type AssistantEvent = Parameters<AssistantMessageEventStream["push"]>[0];
-
-export interface AssistantEventSink {
-	push(event: AssistantEvent): void;
-}
-
-function textOf(message: AssistantMessage): string {
-	const content = message.content[0];
-	return content?.type === "text" ? content.text : "";
-}
-
-export async function emitRemoteResponse(
-	stream: AssistantEventSink,
-	output: AssistantMessage,
-	send: (onSnapshot: (snapshot: string) => void) => Promise<string>,
-	onOutputStart: () => void = () => {},
-): Promise<void> {
-	let previous = "";
-	let started = false;
-	const update = (snapshot: string) => {
-		if (snapshot === previous) return;
-		const delta = snapshot.startsWith(previous) ? snapshot.slice(previous.length) : "";
-		if (!started) {
-			output.content.push({ type: "text", text: "" });
-			started = true;
-			onOutputStart();
-			stream.push({ type: "text_start", contentIndex: 0, partial: output });
-		}
-		const content = output.content[0];
-		if (content?.type === "text") content.text = snapshot;
-		previous = snapshot;
-		stream.push({ type: "text_delta", contentIndex: 0, delta, partial: output });
-	};
-
-	const final = await send(update);
-	update(final);
-	if (!started) update("");
-	stream.push({ type: "text_end", contentIndex: 0, content: textOf(output), partial: output });
-	output.stopReason = "stop";
-	stream.push({ type: "done", reason: "stop", message: output });
-}

package/src/session-target.ts

@@ -1,66 +0,0 @@
-export interface RelayTarget {
-	mode: "relay";
-	baseUrl: string;
-	key: string;
-	workspaceId: string;
-	serviceUrl: string;
-}
-
-export interface DirectTarget {
-	mode: "direct";
-	key: string;
-	serviceUrl: string;
-}
-
-export interface UnsetTarget {
-	mode: "unset";
-	baseUrl: string;
-	key: string;
-}
-
-export type SessionTarget = RelayTarget | DirectTarget | UnsetTarget;
-
-export function relayTarget(baseUrl: string, key: string, workspaceId: string): RelayTarget {
-	const base = baseUrl.replace(/\/$/, "");
-	return {
-		mode: "relay",
-		baseUrl: base,
-		key,
-		workspaceId,
-		serviceUrl: `${base}/v1/workspaces/${encodeURIComponent(workspaceId)}/agent`,
-	};
-}
-
-export function targetFromEnvironment(env: NodeJS.ProcessEnv = process.env): SessionTarget {
-	const key = env.POCKETCODER_KEY;
-	if (!key) throw new Error("POCKETCODER_KEY is required");
-	const directUrl = env.POCKETCODER_AGENTAPI_URL;
-	if (directUrl) return { mode: "direct", key, serviceUrl: directUrl.replace(/\/$/, "") };
-
-	const baseUrl = (env.POCKETCODER_URL ?? "http://127.0.0.1:7080").replace(/\/$/, "");
-	const workspaceId = env.POCKETCODER_WORKSPACE_ID;
-	if (!workspaceId) return { mode: "unset", baseUrl, key };
-	return relayTarget(baseUrl, key, workspaceId);
-}
-
-export class TargetRef {
-	private target: SessionTarget;
-	private readonly listeners: Array<(target: SessionTarget) => void> = [];
-
-	constructor(initial: SessionTarget) {
-		this.target = initial;
-	}
-
-	get current(): SessionTarget {
-		return this.target;
-	}
-
-	set(next: SessionTarget): void {
-		this.target = next;
-		for (const listener of this.listeners) listener(next);
-	}
-
-	onChange(listener: (target: SessionTarget) => void): void {
-		this.listeners.push(listener);
-	}
-}

package/src/status.ts

@@ -1,121 +0,0 @@
-import type { ControlPlaneClient, WorkspaceSummary } from "./control-plane";
-import { TERMINAL_WORKSPACE_STATES } from "./control-plane";
-
-export const STATUS_KEY = "pocketcoder";
-
-export interface StatusUi {
-	setStatus(key: string, text: string | undefined): void;
-	notify(message: string, type?: "info" | "warning" | "error"): void;
-}
-
-export interface StatusPollerOptions {
-	waitSeconds?: number;
-	delay?: (ms: number) => Promise<void>;
-}
-
-export function statusText(
-	workspace: Pick<WorkspaceSummary, "id" | "state" | "agent_state">,
-): string {
-	return `ws ${workspace.id.slice(0, 8)} · ${workspace.state}/${workspace.agent_state}`;
-}
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Keeps the status bar in sync with the workspace via the durable change
- * cursor. Paused during turns so RemoteAgentClient.send() is the only
- * consumer of the change feed while the agent is working.
- */
-export class StatusPoller {
-	private readonly controlPlane: ControlPlaneClient;
-	private readonly workspaceId: string;
-	private readonly ui: StatusUi;
-	private readonly waitSeconds: number;
-	private readonly delay: (ms: number) => Promise<void>;
-	private cursor: number;
-	private paused = false;
-	private stopped = false;
-	private wake: (() => void) | undefined;
-	private controller: AbortController | undefined;
-	private loop: Promise<void> | undefined;
-	private lastText: string | undefined;
-
-	constructor(
-		controlPlane: ControlPlaneClient,
-		workspace: Pick<WorkspaceSummary, "id" | "change_cursor">,
-		ui: StatusUi,
-		options: StatusPollerOptions = {},
-	) {
-		this.controlPlane = controlPlane;
-		this.workspaceId = workspace.id;
-		this.cursor = workspace.change_cursor ?? 0;
-		this.ui = ui;
-		this.waitSeconds = options.waitSeconds ?? 30;
-		this.delay = options.delay ?? sleep;
-	}
-
-	start(): void {
-		if (!this.loop) this.loop = this.run();
-	}
-
-	pause(): void {
-		this.paused = true;
-		this.controller?.abort();
-	}
-
-	resume(): void {
-		if (!this.paused) return;
-		this.paused = false;
-		this.wake?.();
-	}
-
-	async stop(): Promise<void> {
-		this.stopped = true;
-		this.controller?.abort();
-		this.wake?.();
-		await this.loop;
-		this.ui.setStatus(STATUS_KEY, undefined);
-	}
-
-	private async run(): Promise<void> {
-		let backoffMs = 1_000;
-		while (!this.stopped) {
-			if (this.paused) {
-				await new Promise<void>((resolve) => {
-					this.wake = resolve;
-				});
-				continue;
-			}
-			this.controller = new AbortController();
-			try {
-				const change = await this.controlPlane.workspaces.change(
-					this.workspaceId,
-					this.cursor,
-					this.waitSeconds,
-					{ signal: this.controller.signal },
-				);
-				backoffMs = 1_000;
-				this.cursor = change.cursor;
-				this.lastText = statusText(change.workspace);
-				this.ui.setStatus(STATUS_KEY, this.lastText);
-				if (TERMINAL_WORKSPACE_STATES.has(change.workspace.state)) {
-					this.ui.notify(
-						`workspace ${change.workspace.id.slice(0, 8)} is ${change.workspace.state}`,
-						change.workspace.state === "succeeded" ? "info" : "warning",
-					);
-					return;
-				}
-			} catch {
-				if (this.stopped || this.paused) continue;
-				this.ui.setStatus(
-					STATUS_KEY,
-					`${this.lastText ?? `ws ${this.workspaceId.slice(0, 8)}`} · reconnecting`,
-				);
-				await this.delay(backoffMs);
-				backoffMs = Math.min(backoffMs * 2, 30_000);
-			}
-		}
-	}
-}