@zetaloop/chappie 0.4.0 → 0.5.0

package/src/session.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { access } from "node:fs/promises";
 import { hostname } from "node:os";
-import { join } from "node:path";
+import { resolve } from "node:path";
 import type {
 	AssistantMessage,
 	ToolResultMessage,
@@ -22,10 +22,18 @@ import {
 	type SessionDescription,
 	type SessionInput,
 	type SessionInspection,
+	type SessionRequest,
+	type SessionResult,
 	type SessionStatus,
 } from "./ipc.ts";
 import type { ProviderOutput } from "./provider.ts";
-import { readSessionResource, rememberImages } from "./resources.ts";
+import {
+	type ResourceDescriptor,
+	readSessionResource,
+	rememberImages,
+	resourceSessionId,
+} from "./resources.ts";
+import { copyFiles, transfer, transferResult } from "./transfer.ts";
 
 type RemoteRequest = Extract<BrokerMessage, { type: "chat" | "call" }>;
 
@@ -44,6 +52,16 @@ interface StoreRequest {
 	reject(error: Error): void;
 }
 
+interface PendingRequest {
+	resolve(result: SessionResult): void;
+	reject(error: Error): void;
+}
+
+interface HistoryRequest {
+	request: Extract<BrokerMessage, { type: "history" }>;
+	timeout: NodeJS.Timeout;
+}
+
 interface ActiveRequest {
 	request: RemoteRequest;
 	session: SessionDescription;
@@ -62,12 +80,15 @@ export class LocalSession {
 	readonly #queue: RemoteRequest[] = [];
 	readonly #pendingInputs = new Map<string, SessionInput>();
 	readonly #deliveries = new Map<string, DeliveryRecord>();
+	readonly #histories = new Map<number, HistoryRequest>();
+	readonly #requests = new Map<number, PendingRequest>();
+	readonly #copies = new Map<number, AbortController>();
 	#context: ExtensionContext | undefined;
 	#connection: IpcClient | undefined;
 	#output: ProviderOutput | undefined;
 	#active: ActiveRequest | undefined;
 	#status: SessionStatus = "idle";
-	#nextSyncId = 1;
+	#nextRequestId = 1;
 	#starting = false;
 	#sessionId: string | undefined;
 	#inputCursor: string | null = null;
@@ -104,6 +125,20 @@ export class LocalSession {
 			if (context.model?.provider === "chappie") {
 				this.#resetInputs(context, event.newLeafId);
 			}
+			this.#historyChanged();
+		});
+		// Pi persists messages after message_end handlers finish.
+		this.#pi.on("message_start", (_event, context) => {
+			this.#context = context;
+			this.#historyChanged();
+		});
+		this.#pi.on("tool_call", (_event, context) => {
+			this.#context = context;
+			this.#historyChanged();
+		});
+		this.#pi.on("session_compact", (_event, context) => {
+			this.#context = context;
+			this.#historyChanged();
 		});
 		this.#pi.on("context", (event, context) => ({
 			messages:
@@ -122,6 +157,7 @@ export class LocalSession {
 			this.#context = context;
 			this.#starting = false;
 			this.#collectInputs();
+			this.#historyChanged();
 			await this.#completeActive();
 			this.#dispatch();
 		});
@@ -139,6 +175,7 @@ export class LocalSession {
 				type,
 				...activity,
 			});
+		if (activity.event !== "history") this.#historyChanged();
 	}
 
 	async start(output: ProviderOutput): Promise<void> {
@@ -157,6 +194,7 @@ export class LocalSession {
 			await connection.connect();
 			if (output.closed) return;
 			this.#collectInputs();
+			this.#historyChanged();
 			await this.#completeActive();
 			this.#status = "ready";
 			await this.#sync();
@@ -171,6 +209,52 @@ export class LocalSession {
 		}
 	}
 
+	async transfer(
+		...parameters: Parameters<typeof transfer.execute>
+	): ReturnType<typeof transfer.execute> {
+		const [id, args, signal, update, context] = parameters;
+		if (!args.to) return transfer.execute(...parameters);
+		if (args.files) throw new Error("files and to are mutually exclusive");
+		if (args.paths.length !== args.to.paths.length)
+			throw new Error("Source and destination counts must match");
+		const inspected = await this.#request(
+			{ type: "inspect", sessionId: args.to.sessionId },
+			signal,
+		);
+		if (!("inspection" in inspected))
+			throw new Error("Pi session returned no environment");
+		const exported = await transfer.execute(
+			id,
+			{ paths: args.paths },
+			signal,
+			undefined,
+			context,
+		);
+		update?.({
+			content: [],
+			details: {
+				...exported.details,
+				to: {
+					sessionId: args.to.sessionId,
+					device: inspected.inspection.session.device,
+				},
+			},
+		});
+		const result = await this.#request(
+			{
+				type: "copy",
+				sessionId: args.to.sessionId,
+				paths: args.to.paths,
+				resources: exported.details.resources,
+				...(args.overwrite !== undefined ? { overwrite: args.overwrite } : {}),
+			},
+			signal,
+		);
+		if (!("transfer" in result))
+			throw new Error("Pi session returned no transfer result");
+		return transferResult({ ...result.transfer, device: hostname() });
+	}
+
 	close(): void {
 		const sessionId = this.#context?.sessionManager.getSessionId();
 		if (sessionId && this.#connection?.connected) {
@@ -187,8 +271,10 @@ export class LocalSession {
 		this.#connection = undefined;
 		this.#context = undefined;
 		this.#resetInputs();
+		this.#cancelRequests(new Error("Chappie session ended"));
 		this.#rejectSyncs(new Error("Chappie session ended"));
 		this.#rejectStores(new Error("Chappie session ended"));
+		for (const id of this.#histories.keys()) this.#finishHistory(id);
 	}
 
 	#update(
@@ -211,6 +297,8 @@ export class LocalSession {
 				},
 				onMessage: (message) => this.#receive(message),
 				onClose: (error) => {
+					this.#cancelRequests(error);
+					for (const id of this.#histories.keys()) this.#finishHistory(id);
 					this.#rejectSyncs(error);
 					this.#rejectStores(error);
 					if (this.#output && !this.#output.closed) this.#output.fail(error);
@@ -248,7 +336,7 @@ export class LocalSession {
 			this.#context.model?.provider !== "chappie"
 		)
 			return;
-		const id = this.#nextSyncId++;
+		const id = this.#nextRequestId++;
 		const completion = Promise.withResolvers<void>();
 		this.#syncs.set(id, completion);
 		try {
@@ -261,6 +349,16 @@ export class LocalSession {
 
 	async #receive(message: BrokerMessage): Promise<void> {
 		switch (message.type) {
+			case "response": {
+				const pending = this.#requests.get(message.id);
+				if (!pending) break;
+				if ("error" in message) pending.reject(new Error(message.error));
+				else {
+					const { type: _type, id: _id, ...result } = message;
+					pending.resolve(result);
+				}
+				break;
+			}
 			case "synced":
 				this.#syncs.get(message.id)?.resolve();
 				break;
@@ -276,7 +374,7 @@ export class LocalSession {
 				break;
 			case "inspect":
 				await this.#reply(message.id, message.sessionId, async () => {
-					const globalAgents = await this.#readGlobalAgents();
+					const globalAgents = await this.#globalAgents();
 					return {
 						type: "result",
 						id: message.id,
@@ -287,24 +385,7 @@ export class LocalSession {
 				});
 				break;
 			case "history":
-				await this.#reply(message.id, message.sessionId, () => {
-					const context = this.#context;
-					if (!context) throw new Error("Chappie session is not available");
-					const history = historyResult(
-						context.sessionManager.getBranch(),
-						message.sessionId,
-						message.range,
-					);
-					this.#notify(
-						`${chatLabel(message)} read history: ${history.count} entries`,
-						"info",
-						{
-							event: "history",
-							...source(message.chatId, message.requestId),
-						},
-					);
-					return { type: "result", id: message.id, cwd: context.cwd, history };
-				});
+				await this.#readHistory(message);
 				break;
 			case "ackInputs":
 				if (
@@ -317,10 +398,52 @@ export class LocalSession {
 				await this.#reply(message.id, message.sessionId, async () => ({
 					type: "result",
 					id: message.id,
-					resource: await readSessionResource(message.sessionId, message.uri),
+					resource: await readSessionResource(
+						message.sessionId,
+						message.uri,
+						message.offset,
+					),
 				}));
 				break;
+			case "copy": {
+				const controller = new AbortController();
+				this.#copies.set(message.id, controller);
+				void this.#reply(message.id, message.sessionId, async () => {
+					const context = this.#context;
+					if (!context) throw new Error("Chappie session is not available");
+					const files = await copyFiles(
+						message.paths,
+						message.resources,
+						context.cwd,
+						message.overwrite === true,
+						(resource) => this.#readChunks(resource, controller.signal),
+						controller.signal,
+					);
+					return {
+						type: "result",
+						id: message.id,
+						transfer: {
+							device: hostname(),
+							files,
+							resources: [],
+							to: { sessionId: message.sessionId, device: hostname() },
+						},
+					};
+				})
+					.finally(() => this.#copies.delete(message.id))
+					.catch(() => {});
+				break;
+			}
 			case "cancel": {
+				const copying = this.#copies.get(message.id);
+				if (copying) {
+					copying.abort(new Error(message.reason));
+					break;
+				}
+				if (this.#histories.has(message.id)) {
+					this.#finishHistory(message.id);
+					break;
+				}
 				const queued = this.#queue.findIndex(
 					(request) => request.id === message.id,
 				);
@@ -370,6 +493,125 @@ export class LocalSession {
 		}
 	}
 
+	async #request(
+		request: SessionRequest,
+		signal?: AbortSignal,
+	): Promise<SessionResult> {
+		signal?.throwIfAborted();
+		const connection = this.#connection;
+		if (!connection?.connected) throw new Error("Chappie is not connected");
+		const id = this.#nextRequestId++;
+		const completion = Promise.withResolvers<SessionResult>();
+		const onAbort = (): void => {
+			completion.reject(signal?.reason);
+			void connection.send({ type: "cancelRequest", id }).catch(() => {});
+		};
+		this.#requests.set(id, completion);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		void connection
+			.send({ type: "request", id, request })
+			.catch(completion.reject);
+		try {
+			return await completion.promise;
+		} finally {
+			this.#requests.delete(id);
+			signal?.removeEventListener("abort", onAbort);
+		}
+	}
+
+	async *#readChunks(
+		resource: ResourceDescriptor,
+		signal: AbortSignal,
+	): AsyncGenerator<Uint8Array> {
+		for (let offset = 0; offset < resource.size; ) {
+			const result = await this.#request(
+				{
+					type: "readResource",
+					sessionId: resourceSessionId(resource.uri),
+					uri: resource.uri,
+					offset,
+				},
+				signal,
+			);
+			if (!("resource" in result))
+				throw new Error("Pi session returned no resource");
+			const data = Buffer.from(result.resource.blob, "base64");
+			if (data.length === 0)
+				throw new Error(
+					`Source ended before ${resource.size} bytes: ${resource.name}`,
+				);
+			yield data;
+			offset += data.length;
+		}
+	}
+
+	#cancelRequests(error: Error): void {
+		for (const pending of this.#requests.values()) pending.reject(error);
+		this.#requests.clear();
+		for (const controller of this.#copies.values()) controller.abort(error);
+		this.#copies.clear();
+	}
+
+	async #readHistory(
+		request: HistoryRequest["request"],
+		wait = request.range.wait,
+	): Promise<void> {
+		try {
+			const context = this.#context;
+			if (context?.sessionManager.getSessionId() !== request.sessionId)
+				throw new Error("The requested Pi session is no longer active");
+			const history = historyResult(
+				context.sessionManager.getBranch(),
+				request.sessionId,
+				request.range,
+			);
+			if (wait && !request.range.before && history.count === 0) {
+				if (!this.#histories.has(request.id)) {
+					this.#histories.set(request.id, {
+						request,
+						timeout: setTimeout(() => {
+							void this.#readHistory(request, false).catch(() => {});
+						}, 30_000),
+					});
+				}
+				return;
+			}
+			this.#finishHistory(request.id);
+			if (!request.range.observer) {
+				this.#notify(
+					`${chatLabel(request)} read history: ${history.count} entries`,
+					"info",
+					{ event: "history", ...source(request.chatId, request.requestId) },
+				);
+			}
+			await this.#connection?.send({
+				type: "result",
+				id: request.id,
+				cwd: context.cwd,
+				history,
+			});
+		} catch (error) {
+			this.#finishHistory(request.id);
+			await this.#sendError(
+				request.id,
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	}
+
+	#historyChanged(): void {
+		for (const { request } of this.#histories.values()) {
+			void this.#readHistory(request).catch(() => {});
+		}
+	}
+
+	#finishHistory(id: number): void {
+		const pending = this.#histories.get(id);
+		if (!pending) return;
+		clearTimeout(pending.timeout);
+		this.#histories.delete(id);
+	}
+
 	#inspection(): SessionInspection {
 		const activeTools = new Set(this.#pi.getActiveTools());
 		this.#collectInputs();
@@ -384,9 +626,11 @@ export class LocalSession {
 		};
 	}
 
-	async #readGlobalAgents(): Promise<string | undefined> {
+	async #globalAgents(): Promise<{ path: string } | undefined> {
+		const path = resolve(this.#agentDir, "AGENTS.md");
 		try {
-			return await readFile(join(this.#agentDir, "AGENTS.md"), "utf8");
+			await access(path);
+			return { path };
 		} catch (error) {
 			if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
 			throw error;
@@ -450,6 +694,7 @@ export class LocalSession {
 		context: ExtensionContext,
 	): Promise<void> {
 		this.#context = context;
+		this.#historyChanged();
 		const active = this.#active;
 		if (!active || message !== active.message) return;
 		const sessionId = active.session.id;

package/src/state.ts

@@ -5,7 +5,6 @@ import type { QuestionAnswer, QuestionRecord } from "./questions.ts";
 
 interface StateFile {
 	bindings?: Record<string, string>;
-	codes?: Record<string, string>;
 	deliveries?: DeliveryRecord[];
 	questions?: QuestionRecord[];
 }
@@ -14,7 +13,6 @@ export class State {
 	readonly #path: string;
 	readonly #temporaryPath: string;
 	readonly #bindings = new Map<string, string>();
-	readonly #codes = new Map<string, string>();
 	readonly #deliveries = new Map<string, DeliveryRecord>();
 	readonly #questions = new Map<string, QuestionRecord>();
 	#writes = Promise.resolve();
@@ -36,9 +34,6 @@ export class State {
 		for (const [chatId, sessionId] of Object.entries(state.bindings ?? {})) {
 			if (typeof sessionId === "string") this.#bindings.set(chatId, sessionId);
 		}
-		for (const [sessionId, code] of Object.entries(state.codes ?? {})) {
-			this.#codes.set(sessionId, code);
-		}
 		for (const delivery of state.deliveries ?? []) {
 			if (delivery?.id) this.#deliveries.set(delivery.id, delivery);
 		}
@@ -46,16 +41,6 @@ export class State {
 			this.#questions.set(question.id, question);
 	}
 
-	code(sessionId: string): string | undefined {
-		return this.#codes.get(sessionId);
-	}
-
-	setCode(sessionId: string, code: string | undefined): Promise<void> {
-		if (code === undefined) this.#codes.delete(sessionId);
-		else this.#codes.set(sessionId, code);
-		return this.#save();
-	}
-
 	binding(chatId: string): string | undefined {
 		return this.#bindings.get(chatId);
 	}
@@ -163,10 +148,9 @@ export class State {
 	#save(): Promise<void> {
 		const saved = this.#writes.then(async () => {
 			const bindings = Object.fromEntries(this.#bindings);
-			const codes = Object.fromEntries(this.#codes);
 			await writeFile(
 				this.#temporaryPath,
-				`${JSON.stringify({ bindings, codes, deliveries: [...this.#deliveries.values()], questions: [...this.#questions.values()] }, null, 2)}\n`,
+				`${JSON.stringify({ bindings, deliveries: [...this.#deliveries.values()], questions: [...this.#questions.values()] }, null, 2)}\n`,
 				{
 					mode: 0o600,
 				},