@zetaloop/chappie 0.4.0 → 0.5.0

package/src/transfer.ts

@@ -1,20 +1,35 @@
 import { once } from "node:events";
 import { createWriteStream } from "node:fs";
-import { mkdir, stat, unlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, resolve } from "node:path";
+import {
+	link,
+	mkdir,
+	mkdtempDisposable,
+	rename,
+	stat,
+	unlink,
+} from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import {
-	type ExtensionContext,
+	formatSize,
+	type ToolDefinition,
 	withFileMutationQueue,
 } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { describeResource, registerFile } from "./resources.ts";
+import {
+	describeResource,
+	type ResourceDescriptor,
+	registerFile,
+} from "./resources.ts";
 
-interface TransferDetails {
+export interface TransferDetails {
+	device: string;
 	files: ({ path: string; bytes: number } | { path: string; error: string })[];
-	resources: import("./resources.ts").ResourceDescriptor[];
+	resources: ResourceDescriptor[];
+	to?: { sessionId: string; device: string };
 }
 
 export const transferFile = Type.Object({
@@ -24,43 +39,52 @@ export const transferFile = Type.Object({
 	mime_type: Type.Optional(Type.String()),
 });
 
-export const transfer = {
-	name: "transfer",
-	label: "transfer",
-	description:
-		"Copy ChatGPT files into Pi paths when files is supplied. Otherwise, return resource links for Pi paths or Chappie image references.",
-	parameters: Type.Object({
-		paths: Type.Array(Type.String(), {
+const parameters = Type.Object({
+	paths: Type.Array(Type.String(), {
+		minItems: 1,
+		description:
+			"Pi destinations for import; Pi source paths or chappie:// image references for export or session copies",
+	}),
+	files: Type.Optional(
+		Type.Array(transferFile, {
 			minItems: 1,
 			description:
-				"Pi destinations for import; Pi paths or chappie:// image references for export",
+				"ChatGPT files paired with paths in order; omit for Pi sources",
 		}),
-		files: Type.Optional(
-			Type.Array(transferFile, {
+	),
+	to: Type.Optional(
+		Type.Object({
+			sessionId: Type.String({ description: "Destination Pi session" }),
+			paths: Type.Array(Type.String(), {
 				minItems: 1,
-				description:
-					"ChatGPT files paired with paths in order; omit for export",
+				description: "Destinations paired with source paths in order",
 			}),
-		),
-		overwrite: Type.Optional(
-			Type.Boolean({ description: "Overwrite existing target files" }),
-		),
-	}),
+		}),
+	),
+	overwrite: Type.Optional(
+		Type.Boolean({ description: "Overwrite existing target files" }),
+	),
+});
+
+export const transfer = {
+	name: "transfer",
+	label: "transfer",
+	description:
+		"Copy ChatGPT files into Pi paths with files, or copy Pi files to another session with to. Otherwise, return resource links for Pi paths or Chappie image references.",
+	parameters,
 	async execute(
-		_id: string,
-		args: {
-			paths: string[];
-			files?: { download_url: string }[];
-			overwrite?: boolean;
-		},
-		signal: AbortSignal | undefined,
-		_update: unknown,
-		context: ExtensionContext,
+		_id,
+		args,
+		signal,
+		update,
+		context,
 	): Promise<{
 		content: { type: "text"; text: string }[];
 		details: TransferDetails;
 	}> {
 		const sessionId = context.sessionManager.getSessionId();
+		const device = hostname();
+		update?.({ content: [], details: { device, files: [], resources: [] } });
 		if (!args.files) {
 			const resources = await Promise.all(
 				args.paths.map((requested) =>
@@ -73,7 +97,7 @@ export const transfer = {
 				content: [
 					{ type: "text" as const, text: JSON.stringify({ resources }) },
 				],
-				details: { files: [], resources },
+				details: { device, files: [], resources },
 			};
 		}
 
@@ -104,15 +128,140 @@ export const transfer = {
 				}
 			}),
 		);
-		if (files.some((file) => "error" in file)) {
-			throw new Error(JSON.stringify({ files }));
+		return transferResult({ device, files, resources: [] });
+	},
+	renderCall(args, theme, context) {
+		const device = context.state.device ?? hostname();
+		const from = args.files ? "ChatGPT" : device;
+		const to = args.files
+			? device
+			: (context.state.to ?? (args.to ? "Pi" : "ChatGPT"));
+		const header =
+			context.lastComponent instanceof Text
+				? context.lastComponent
+				: new Text("", 0, 0);
+		header.setText(theme.fg("toolTitle", theme.bold(`${from} → ${to}`)));
+		context.state.header = header;
+		return header;
+	},
+	renderResult(result, _options, theme, context) {
+		const details = result.details;
+		if (!details) {
+			const text = result.content
+				.flatMap((block) => (block.type === "text" ? [block.text] : []))
+				.join("\n");
+			return new Text(
+				theme.fg(context.isError ? "error" : "toolOutput", text),
+				0,
+				0,
+			);
 		}
-		return {
-			content: [{ type: "text" as const, text: JSON.stringify({ files }) }],
-			details: { files, resources: [] },
-		};
+		const args = context.args;
+		context.state.device = details.device;
+		context.state.to = details.to?.device ?? "ChatGPT";
+		const from = args.files ? "ChatGPT" : details.device;
+		const to = args.files ? details.device : (details.to?.device ?? "ChatGPT");
+		context.state.header?.setText(
+			theme.fg("toolTitle", theme.bold(`${from} → ${to}`)),
+		);
+		const lines =
+			details.resources.length > 0
+				? details.resources.map((resource, index) => {
+						const source = displayPath(args.paths?.[index] ?? resource.name);
+						const destination = args.to?.paths[index];
+						return `${destination ? `${source} → ${destination}` : source}  ${theme.fg("dim", formatSize(resource.size))}`;
+					})
+				: details.files.length > 0
+					? details.files.map((file, index) => {
+							const source = args.to
+								? args.paths?.[index]
+								: args.files?.[index]?.file_name;
+							const path = source
+								? `${displayPath(source)} → ${file.path}`
+								: file.path;
+							return "error" in file
+								? theme.fg("error", `${path}\n${file.error}`)
+								: `${path}  ${theme.fg("dim", formatSize(file.bytes))}`;
+						})
+					: (args.paths ?? []).map((path, index) =>
+							args.to?.paths[index]
+								? `${displayPath(path)} → ${args.to.paths[index]}`
+								: displayPath(path),
+						);
+		return new Text(lines.join("\n"), 0, 0);
 	},
-};
+} satisfies ToolDefinition<
+	typeof parameters,
+	TransferDetails,
+	{ header?: Text; device?: string; to?: string }
+>;
+
+function displayPath(path: string): string {
+	return path.startsWith("chappie://")
+		? decodeURIComponent(basename(new URL(path).pathname))
+		: path;
+}
+
+export function transferResult(details: TransferDetails): {
+	content: { type: "text"; text: string }[];
+	details: TransferDetails;
+} {
+	if (details.files.some((file) => "error" in file)) {
+		throw new Error(
+			details.files
+				.map((file) =>
+					"error" in file
+						? `${file.path}: ${file.error}`
+						: `${file.path}  ${formatSize(file.bytes)}`,
+				)
+				.join("\n"),
+		);
+	}
+	return {
+		content: [{ type: "text", text: JSON.stringify(details) }],
+		details,
+	};
+}
+
+export async function copyFiles(
+	paths: string[],
+	resources: ResourceDescriptor[],
+	cwd: string,
+	overwrite: boolean,
+	read: (resource: ResourceDescriptor) => AsyncIterable<Uint8Array>,
+	signal: AbortSignal,
+): Promise<TransferDetails["files"]> {
+	if (paths.length !== resources.length)
+		throw new Error("Source and destination counts must match");
+	return Promise.all(
+		paths.map(async (requested, index) => {
+			const path = localPath(requested, cwd);
+			try {
+				const resource = resources[index];
+				if (!resource) throw new Error("Missing source resource");
+				const bytes = await withFileMutationQueue(path, async () => {
+					signal.throwIfAborted();
+					await mkdir(dirname(path), { recursive: true });
+					await using temporary = await mkdtempDisposable(
+						join(dirname(path), ".chappie-"),
+					);
+					const staged = join(temporary.path, "file");
+					const bytes = await importFile(staged, read(resource), false, signal);
+					signal.throwIfAborted();
+					if (overwrite) await rename(staged, path);
+					else await link(staged, path);
+					return bytes;
+				});
+				return { path, bytes };
+			} catch (error) {
+				return {
+					path: requested,
+					error: error instanceof Error ? error.message : String(error),
+				};
+			}
+		}),
+	);
+}
 
 function localPath(path: string, cwd: string): string {
 	if (path === "~") return homedir();
@@ -124,7 +273,7 @@ function localPath(path: string, cwd: string): string {
 
 async function importFile(
 	path: string,
-	url: string,
+	source: string | AsyncIterable<Uint8Array>,
 	overwrite: boolean,
 	signal?: AbortSignal,
 ): Promise<number> {
@@ -138,13 +287,15 @@ async function importFile(
 		try {
 			await once(writable, "open");
 			opened = true;
-			const response = await fetch(url, signal ? { signal } : {});
-			if (!response.ok || !response.body) {
-				throw new Error(`Download failed with HTTP ${response.status}`);
-			}
-			const readable = Readable.from(
-				response.body as unknown as AsyncIterable<Uint8Array>,
-			);
+			let content: AsyncIterable<Uint8Array>;
+			if (typeof source === "string") {
+				const response = await fetch(source, signal ? { signal } : {});
+				if (!response.ok || !response.body) {
+					throw new Error(`Download failed with HTTP ${response.status}`);
+				}
+				content = response.body as unknown as AsyncIterable<Uint8Array>;
+			} else content = source;
+			const readable = Readable.from(content, { objectMode: false });
 			if (signal) await pipeline(readable, writable, { signal });
 			else await pipeline(readable, writable);
 			signal?.throwIfAborted();