pi-protonmail 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 0.2.0 - 2026-07-02
+
+- Added outgoing Proton Bridge tools for draft creation, SMTP sending, message moving, and label application.
+- Added MIME composition with local attachments through `nodemailer`.
+- Added profile `default_from` support for outgoing mail sender resolution.
+- Added Conventional Commits guidance for future repository commits.
+
+## 0.1.0
+
 - Kept `/protonmail` as the single config command and moved Bridge/status/message handling into `protonmail_*` tools.
 - Replaced the Python Bridge helper with a native TypeScript module and kept attachment import staging under profile-specific workspaces.
 - Aligned the package metadata and docs with the Proton Mail workflow.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-protonmail",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"type": "module",
 	"description": "Proton Mail Bridge Pi extension for mailbox discovery and attachment imports.",
 	"homepage": "https://github.com/eirenik0/pi-protonmail#readme",
@@ -50,10 +50,12 @@
 	"dependencies": {
 		"effect": "^3.0.0",
 		"imapflow": "^1.1.1",
-		"mailparser": "^3.9.0"
+		"mailparser": "^3.9.0",
+		"nodemailer": "^6.10.1"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.5.0"
+		"@biomejs/biome": "^2.5.0",
+		"@types/nodemailer": "^8.0.1"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",

package/src/proton-bridge.ts

@@ -1,17 +1,24 @@
-import { access, copyFile, mkdir, writeFile } from "node:fs/promises";
+import { access, copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { createConnection } from "node:net";
-import { join, relative } from "node:path";
+import { basename, isAbsolute, join, relative } from "node:path";
 
 import { ImapFlow } from "imapflow";
 import { simpleParser } from "mailparser";
+import nodemailer from "nodemailer";
+import MailComposer from "nodemailer/lib/mail-composer/index.js";
+import type Mail from "nodemailer/lib/mailer/index.js";
 
 import type {
+	ApplyLabelsResult,
 	BridgeStatusResult,
+	CreateDraftResult,
 	MailboxInfo,
 	MailboxListResult,
 	MessageInfo,
 	MessageListResult,
+	MoveMessageResult,
 	ProtonBridgeConfig,
+	SendMessageResult,
 } from "./types.ts";
 
 export interface ProtonBridgeImportResult {
@@ -46,7 +53,7 @@ interface ImportOptions {
 	cwd: string;
 	workspaceRoot: string;
 	period: string;
-	mailbox: string;
+	mailbox?: string;
 	profile: string;
 	unseenOnly?: boolean;
 	query?: string;
@@ -54,6 +61,37 @@ interface ImportOptions {
 	limit?: number;
 }
 
+interface OutgoingMessageOptions {
+	cwd: string;
+	from: string;
+	to: string[];
+	cc?: string[];
+	bcc?: string[];
+	subject: string;
+	body: string;
+	attachments?: string[];
+}
+
+interface CreateDraftOptions extends OutgoingMessageOptions {
+	draftsMailbox?: string;
+}
+
+interface SendMessageOptions extends OutgoingMessageOptions {
+	saveToMailbox?: string;
+}
+
+interface MoveMessageOptions {
+	mailbox: string;
+	uid: string;
+	destination: string;
+}
+
+interface ApplyLabelsOptions {
+	mailbox: string;
+	uid: string;
+	labels: string[];
+}
+
 function sanitizeFilename(value: string): string {
 	const text = value.replace(/[\\/:*?"<>|\r\n]+/g, "_").trim();
 	return text.replace(/\s+/g, " ") || "unnamed";
@@ -244,6 +282,80 @@ async function ensureDir(path: string): Promise<void> {
 	await mkdir(path, { recursive: true });
 }
 
+function requireBridgeCredentials(
+	config: ProtonBridgeConfig,
+): asserts config is ProtonBridgeConfig & {
+	username: string;
+	password: string;
+} {
+	if (!config.username || !config.password)
+		throw new Error("Missing Proton Bridge username/password.");
+}
+
+function resolveLocalPath(cwd: string, path: string): string {
+	return isAbsolute(path) ? path : join(cwd, path);
+}
+
+async function buildAttachmentOptions(
+	cwd: string,
+	attachments?: string[],
+): Promise<Mail.Attachment[]> {
+	const files: Mail.Attachment[] = [];
+	for (const attachmentPath of attachments ?? []) {
+		const path = resolveLocalPath(cwd, attachmentPath);
+		files.push({
+			filename: basename(path),
+			content: await readFile(path),
+		});
+	}
+	return files;
+}
+
+async function buildMimeMessage(options: OutgoingMessageOptions, keepBcc = false): Promise<Buffer> {
+	const message = new MailComposer({
+		from: options.from,
+		to: options.to,
+		cc: options.cc,
+		bcc: options.bcc,
+		subject: options.subject,
+		text: options.body,
+		attachments: await buildAttachmentOptions(options.cwd, options.attachments),
+	});
+	const node = message.compile();
+	if (keepBcc) (node as unknown as { keepBcc: boolean }).keepBcc = true;
+	return node.build();
+}
+
+function appendUid(result: unknown): string | undefined {
+	if (!result || typeof result !== "object" || !("uid" in result)) return undefined;
+	const uid = (result as { uid?: unknown }).uid;
+	return uid == null ? undefined : String(uid);
+}
+
+function allRecipients(options: OutgoingMessageOptions): string[] {
+	return [...options.to, ...(options.cc ?? []), ...(options.bcc ?? [])].filter(Boolean);
+}
+
+function messageIdFromRaw(raw: Buffer): string | undefined {
+	const match = raw.toString("utf8").match(/^Message-ID:\s*(.+)$/im);
+	return match?.[1]?.trim();
+}
+
+function resolveLabelMailbox(label: string, mailboxes: MailboxInfo[]): string {
+	const trimmed = label.trim();
+	const candidates = [trimmed, `Labels/${trimmed}`];
+	for (const candidate of candidates) {
+		const exact = mailboxes.find((mailbox) => mailbox.name === candidate);
+		if (exact) return exact.name;
+	}
+	for (const candidate of candidates) {
+		const lower = candidate.toLowerCase();
+		const match = mailboxes.find((mailbox) => mailbox.name.toLowerCase() === lower);
+		if (match) return match.name;
+	}
+	return trimmed;
+}
+
 export async function protonBridgeStatus(config: ProtonBridgeConfig): Promise<BridgeStatusResult> {
 	const imapProbe = await probePort(config.host, config.imapPort);
 	const smtpProbe = await probePort(config.host, config.smtpPort);
@@ -335,6 +447,143 @@ export async function protonBridgeListMessages(
 	}
 }
 
+export async function protonBridgeCreateDraft(
+	config: ProtonBridgeConfig,
+	options: CreateDraftOptions,
+): Promise<CreateDraftResult> {
+	requireBridgeCredentials(config);
+	const mailbox = options.draftsMailbox?.trim() || "Drafts";
+	const raw = await buildMimeMessage(options, true);
+	let client: ImapFlow | undefined;
+	try {
+		client = await connectImap(config);
+		const result = await client.append(mailbox, raw, ["\\Draft", "\\Seen"], new Date());
+		return {
+			mailbox,
+			uid: appendUid(result),
+			from: options.from,
+			to: options.to,
+			cc: options.cc,
+			bcc: options.bcc,
+			subject: options.subject,
+			attachment_count: options.attachments?.length ?? 0,
+		};
+	} finally {
+		await client?.logout().catch(() => undefined);
+	}
+}
+
+export async function protonBridgeSendMessage(
+	config: ProtonBridgeConfig,
+	options: SendMessageOptions,
+): Promise<SendMessageResult> {
+	requireBridgeCredentials(config);
+	const raw = await buildMimeMessage(options);
+	const security = normalizeSecurity(config.security);
+	const transport = nodemailer.createTransport({
+		host: config.host,
+		port: config.smtpPort,
+		secure: security === "ssl",
+		ignoreTLS: security === "plain",
+		requireTLS: security === "starttls",
+		auth: {
+			user: config.username,
+			pass: config.password,
+		},
+		tls: {
+			rejectUnauthorized: false,
+		},
+	});
+
+	let messageId = messageIdFromRaw(raw);
+	try {
+		const info = await transport.sendMail({
+			envelope: {
+				from: options.from,
+				to: allRecipients(options),
+			},
+			raw,
+		});
+		if (typeof info.messageId === "string") messageId = info.messageId;
+	} finally {
+		transport.close();
+	}
+
+	const result: SendMessageResult = {
+		from: options.from,
+		to: options.to,
+		cc: options.cc,
+		bcc: options.bcc,
+		subject: options.subject,
+		attachment_count: options.attachments?.length ?? 0,
+		message_id: messageId,
+	};
+
+	const saveToMailbox = options.saveToMailbox?.trim();
+	if (saveToMailbox) {
+		let client: ImapFlow | undefined;
+		try {
+			client = await connectImap(config);
+			const appendResult = await client.append(saveToMailbox, raw, ["\\Seen"], new Date());
+			result.saved_to_mailbox = saveToMailbox;
+			result.saved_uid = appendUid(appendResult);
+		} finally {
+			await client?.logout().catch(() => undefined);
+		}
+	}
+
+	return result;
+}
+
+export async function protonBridgeMoveMessage(
+	config: ProtonBridgeConfig,
+	options: MoveMessageOptions,
+): Promise<MoveMessageResult> {
+	requireBridgeCredentials(config);
+	let client: ImapFlow | undefined;
+	try {
+		client = await connectImap(config);
+		await client.mailboxOpen(options.mailbox, { readOnly: false });
+		await client.messageMove(options.uid, options.destination, { uid: true });
+		return {
+			uid: options.uid,
+			source: options.mailbox,
+			destination: options.destination,
+		};
+	} finally {
+		await client?.logout().catch(() => undefined);
+	}
+}
+
+export async function protonBridgeApplyLabels(
+	config: ProtonBridgeConfig,
+	options: ApplyLabelsOptions,
+): Promise<ApplyLabelsResult> {
+	requireBridgeCredentials(config);
+	const labels = [...new Set(options.labels.map((label) => label.trim()).filter(Boolean))];
+	if (labels.length === 0) throw new Error("At least one label is required.");
+	let client: ImapFlow | undefined;
+	try {
+		client = await connectImap(config);
+		const mailboxes = await listMailboxes(client);
+		await client.mailboxOpen(options.mailbox, { readOnly: false });
+		const labelMailboxes = [
+			...new Set(labels.map((label) => resolveLabelMailbox(label, mailboxes))),
+		];
+		for (const labelMailbox of labelMailboxes) {
+			await client.messageCopy(options.uid, labelMailbox, { uid: true });
+		}
+		return {
+			uid: options.uid,
+			mailbox: options.mailbox,
+			labels,
+			label_mailboxes: labelMailboxes,
+		};
+	} finally {
+		await client?.logout().catch(() => undefined);
+	}
+}
+
 export async function protonBridgeImportAttachments(
 	config: ProtonBridgeConfig,
 	options: ImportOptions,

package/src/protonmail.ts

@@ -10,19 +10,27 @@ import { Type } from "typebox";
 import { PREVIEW_LINES } from "./constants.ts";
 import { openProtonMailHub } from "./hub.ts";
 import {
+	protonBridgeApplyLabels as runProtonBridgeApplyLabels,
+	protonBridgeCreateDraft as runProtonBridgeCreateDraft,
 	protonBridgeImportAttachments as runProtonBridgeImportAttachments,
 	protonBridgeListMailboxes as runProtonBridgeListMailboxes,
 	protonBridgeListMessages as runProtonBridgeListMessages,
+	protonBridgeMoveMessage as runProtonBridgeMoveMessage,
+	protonBridgeSendMessage as runProtonBridgeSendMessage,
 	protonBridgeStatus as runProtonBridgeStatus,
 } from "./proton-bridge.ts";
 import { resolveSecretReference } from "./secret-refs.ts";
 import type {
+	ApplyLabelsResult,
 	BridgeStatusResult,
 	CommandContext,
+	CreateDraftResult,
 	MailboxListResult,
 	MessageListResult,
+	MoveMessageResult,
 	ProtonBridgeConfig,
 	ProtonMailWorkingProfile,
+	SendMessageResult,
 	ToolContext,
 } from "./types.ts";
 import {
@@ -216,6 +224,13 @@ async function listProtonMessages(
 	return runProtonBridgeListMessages(config, mailbox, period, query, unseenOnly, limit);
 }
 
+function resolveOutgoingFrom(from: string | undefined, profile: ProtonMailWorkingProfile): string {
+	const resolved = from?.trim() || profile.policy.default_from?.trim();
+	if (!resolved)
+		throw new Error("No from address provided and the active profile has no default_from.");
+	return resolved;
+}
+
 function formatStatusSummary(result: BridgeStatusResult): string {
 	const lines = [
 		"# Proton Bridge Status",
@@ -296,6 +311,62 @@ function formatMessageSummary(result: MessageListResult, period?: string): strin
 	return lines.join("\n");
 }
 
+function formatCreateDraftSummary(result: CreateDraftResult): string {
+	const lines = [
+		"# Proton Mail draft created",
+		"",
+		`- Mailbox: \`${result.mailbox}\``,
+		`- UID: ${result.uid ? `\`${result.uid}\`` : "—"}`,
+		`- From: ${result.from}`,
+		`- To: ${result.to.join(", ")}`,
+		`- Subject: ${result.subject}`,
+		`- Attachments: ${result.attachment_count}`,
+	];
+	if (result.cc?.length) lines.push(`- Cc: ${result.cc.join(", ")}`);
+	if (result.bcc?.length) lines.push(`- Bcc: ${result.bcc.join(", ")}`);
+	return lines.join("\n");
+}
+
+function formatSendSummary(result: SendMessageResult): string {
+	const lines = [
+		"# Proton Mail message sent",
+		"",
+		`- Message ID: ${result.message_id ? `\`${result.message_id}\`` : "—"}`,
+		`- From: ${result.from}`,
+		`- To: ${result.to.join(", ")}`,
+		`- Subject: ${result.subject}`,
+		`- Attachments: ${result.attachment_count}`,
+	];
+	if (result.cc?.length) lines.push(`- Cc: ${result.cc.join(", ")}`);
+	if (result.bcc?.length) lines.push(`- Bcc: ${result.bcc.join(", ")}`);
+	if (result.saved_to_mailbox)
+		lines.push(
+			`- Saved copy: \`${result.saved_to_mailbox}\`${result.saved_uid ? ` UID ${result.saved_uid}` : ""}`,
+		);
+	return lines.join("\n");
+}
+
+function formatMoveSummary(result: MoveMessageResult): string {
+	return [
+		"# Proton Mail message moved",
+		"",
+		`- UID: \`${result.uid}\``,
+		`- Source: \`${result.source}\``,
+		`- Destination: \`${result.destination}\``,
+	].join("\n");
+}
+
+function formatApplyLabelsSummary(result: ApplyLabelsResult): string {
+	return [
+		"# Proton Mail labels applied",
+		"",
+		`- UID: \`${result.uid}\``,
+		`- Mailbox: \`${result.mailbox}\``,
+		`- Labels: ${result.labels.map((label) => `\`${label}\``).join(", ")}`,
+		`- Label mailboxes: ${result.label_mailboxes.map((label) => `\`${label}\``).join(", ")}`,
+	].join("\n");
+}
+
 function formatImportSummary(
 	result: {
 		workspace_root: string;
@@ -536,6 +607,234 @@ export default function registerProtonBridgeExtension(pi: ExtensionAPI) {
 		renderResult: renderToolResult,
 	});
 
+	pi.registerTool({
+		name: "protonmail_create_draft",
+		label: "ProtonMail Create Draft",
+		description: "Create a Proton Mail draft through Bridge IMAP APPEND",
+		promptSnippet: "Create a draft with optional attachments in the Drafts mailbox",
+		promptGuidelines: [
+			"Use from when the sender must be explicit; otherwise the active profile default_from is used.",
+			"Attachments are local file paths and are embedded into a multipart MIME message before IMAP APPEND.",
+		],
+		parameters: Type.Object({
+			from: Type.Optional(
+				Type.String({ description: "Sender address; defaults to profile default_from" }),
+			),
+			to: Type.Array(Type.String(), { description: "Recipient email addresses" }),
+			cc: Type.Optional(Type.Array(Type.String(), { description: "Cc recipient email addresses" })),
+			bcc: Type.Optional(
+				Type.Array(Type.String(), { description: "Bcc recipient email addresses" }),
+			),
+			subject: Type.String({ description: "Email subject" }),
+			body: Type.String({ description: "Plain-text email body" }),
+			attachments: Type.Optional(
+				Type.Array(Type.String(), { description: "Local file paths to attach" }),
+			),
+			draftsMailbox: Type.Optional(
+				Type.String({ description: "Drafts mailbox name; defaults to Drafts" }),
+			),
+		}),
+		async execute(
+			_id: string,
+			params: {
+				from?: string;
+				to: string[];
+				cc?: string[];
+				bcc?: string[];
+				subject: string;
+				body: string;
+				attachments?: string[];
+				draftsMailbox?: string;
+			},
+			_signal: AbortSignal,
+			_onUpdate: unknown,
+			ctx: ToolContext,
+		) {
+			const profile = await resolveProtonMailActiveProfile(ctx.cwd);
+			const config = await getProtonBridgeConfig(profile.policy.default_mailbox);
+			if (!config.username || !config.password)
+				throw new Error(protonMailSetupHint(profile.profile));
+			const result = await runProtonBridgeCreateDraft(config, {
+				cwd: ctx.cwd,
+				from: resolveOutgoingFrom(params.from, profile),
+				to: params.to,
+				cc: params.cc,
+				bcc: params.bcc,
+				subject: params.subject,
+				body: params.body,
+				attachments: params.attachments,
+				draftsMailbox: params.draftsMailbox,
+			});
+			return {
+				content: [{ type: "text", text: trimText(formatCreateDraftSummary(result), 160, 16000) }],
+				details: result,
+			};
+		},
+		renderCall(args: { subject: string; to: string[] }, theme: Theme) {
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("protonmail_create_draft "))}${theme.fg("dim", `${args.subject} → ${args.to.join(", ")}`)}`,
+				0,
+				0,
+			);
+		},
+		renderResult: renderToolResult,
+	});
+
+	pi.registerTool({
+		name: "protonmail_send",
+		label: "ProtonMail Send",
+		description: "Send a Proton Mail message through Bridge SMTP",
+		promptSnippet: "Send a message with optional attachments through Proton Bridge SMTP",
+		promptGuidelines: [
+			"Use from when the sender must be explicit; otherwise the active profile default_from is used.",
+			"Use saveToMailbox only when a sent or issued copy should also be appended to an IMAP folder.",
+		],
+		parameters: Type.Object({
+			from: Type.Optional(
+				Type.String({ description: "Sender address; defaults to profile default_from" }),
+			),
+			to: Type.Array(Type.String(), { description: "Recipient email addresses" }),
+			cc: Type.Optional(Type.Array(Type.String(), { description: "Cc recipient email addresses" })),
+			bcc: Type.Optional(
+				Type.Array(Type.String(), { description: "Bcc recipient email addresses" }),
+			),
+			subject: Type.String({ description: "Email subject" }),
+			body: Type.String({ description: "Plain-text email body" }),
+			attachments: Type.Optional(
+				Type.Array(Type.String(), { description: "Local file paths to attach" }),
+			),
+			saveToMailbox: Type.Optional(
+				Type.String({ description: "Optional mailbox for appending a sent copy" }),
+			),
+		}),
+		async execute(
+			_id: string,
+			params: {
+				from?: string;
+				to: string[];
+				cc?: string[];
+				bcc?: string[];
+				subject: string;
+				body: string;
+				attachments?: string[];
+				saveToMailbox?: string;
+			},
+			_signal: AbortSignal,
+			_onUpdate: unknown,
+			ctx: ToolContext,
+		) {
+			const profile = await resolveProtonMailActiveProfile(ctx.cwd);
+			const config = await getProtonBridgeConfig(profile.policy.default_mailbox);
+			if (!config.username || !config.password)
+				throw new Error(protonMailSetupHint(profile.profile));
+			const result = await runProtonBridgeSendMessage(config, {
+				cwd: ctx.cwd,
+				from: resolveOutgoingFrom(params.from, profile),
+				to: params.to,
+				cc: params.cc,
+				bcc: params.bcc,
+				subject: params.subject,
+				body: params.body,
+				attachments: params.attachments,
+				saveToMailbox: params.saveToMailbox,
+			});
+			return {
+				content: [{ type: "text", text: trimText(formatSendSummary(result), 160, 16000) }],
+				details: result,
+			};
+		},
+		renderCall(args: { subject: string; to: string[] }, theme: Theme) {
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("protonmail_send "))}${theme.fg("dim", `${args.subject} → ${args.to.join(", ")}`)}`,
+				0,
+				0,
+			);
+		},
+		renderResult: renderToolResult,
+	});
+
+	pi.registerTool({
+		name: "protonmail_move_message",
+		label: "ProtonMail Move Message",
+		description: "Move a Proton Bridge message between IMAP mailboxes",
+		promptSnippet: "Move a message UID from one Proton folder to another",
+		promptGuidelines: [
+			"Use protonmail_list_messages first when you need to identify the source mailbox UID.",
+			"Pass the exact mailbox names returned by Proton Bridge.",
+		],
+		parameters: Type.Object({
+			mailbox: Type.String({ description: "Source mailbox name" }),
+			uid: Type.String({ description: "Message UID in the source mailbox" }),
+			destination: Type.String({ description: "Destination mailbox name" }),
+		}),
+		async execute(
+			_id: string,
+			params: { mailbox: string; uid: string; destination: string },
+			_signal: AbortSignal,
+			_onUpdate: unknown,
+			ctx: ToolContext,
+		) {
+			const profile = await resolveProtonMailActiveProfile(ctx.cwd);
+			const config = await getProtonBridgeConfig(profile.policy.default_mailbox);
+			if (!config.username || !config.password)
+				throw new Error(protonMailSetupHint(profile.profile));
+			const result = await runProtonBridgeMoveMessage(config, params);
+			return {
+				content: [{ type: "text", text: trimText(formatMoveSummary(result), 160, 16000) }],
+				details: result,
+			};
+		},
+		renderCall(args: { mailbox: string; uid: string; destination: string }, theme: Theme) {
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("protonmail_move_message "))}${theme.fg("dim", `${args.mailbox} UID ${args.uid} → ${args.destination}`)}`,
+				0,
+				0,
+			);
+		},
+		renderResult: renderToolResult,
+	});
+
+	pi.registerTool({
+		name: "protonmail_apply_labels",
+		label: "ProtonMail Apply Labels",
+		description: "Apply Proton labels to a message through Bridge IMAP copy",
+		promptSnippet: "Apply one or more Proton labels to a message UID",
+		promptGuidelines: [
+			"Use protonmail_list_mailboxes when you need the exact label mailbox names returned by Proton Bridge.",
+			"Bare label names are resolved to matching mailboxes or Labels/<name> when available.",
+		],
+		parameters: Type.Object({
+			mailbox: Type.String({ description: "Source mailbox name" }),
+			uid: Type.String({ description: "Message UID in the source mailbox" }),
+			labels: Type.Array(Type.String(), { description: "Labels or label mailbox paths to apply" }),
+		}),
+		async execute(
+			_id: string,
+			params: { mailbox: string; uid: string; labels: string[] },
+			_signal: AbortSignal,
+			_onUpdate: unknown,
+			ctx: ToolContext,
+		) {
+			const profile = await resolveProtonMailActiveProfile(ctx.cwd);
+			const config = await getProtonBridgeConfig(profile.policy.default_mailbox);
+			if (!config.username || !config.password)
+				throw new Error(protonMailSetupHint(profile.profile));
+			const result = await runProtonBridgeApplyLabels(config, params);
+			return {
+				content: [{ type: "text", text: trimText(formatApplyLabelsSummary(result), 160, 16000) }],
+				details: result,
+			};
+		},
+		renderCall(args: { mailbox: string; uid: string; labels: string[] }, theme: Theme) {
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("protonmail_apply_labels "))}${theme.fg("dim", `${args.mailbox} UID ${args.uid} + ${args.labels.join(", ")}`)}`,
+				0,
+				0,
+			);
+		},
+		renderResult: renderToolResult,
+	});
+
 	pi.registerTool({
 		name: "protonmail_import_attachments",
 		label: "ProtonMail Import Attachments",

package/src/types.ts

@@ -15,6 +15,7 @@ export interface ProtonMailProfilePolicy {
 	mailbox_filter?: string;
 	default_period?: string;
 	import_workspace_root?: string;
+	default_from?: string;
 }
 
 export interface ProtonMailWorkspaceConfig {
@@ -82,6 +83,42 @@ export interface MessageListResult {
 	messages: MessageInfo[];
 }
 
+export interface CreateDraftResult {
+	mailbox: string;
+	uid?: string;
+	from: string;
+	to: string[];
+	cc?: string[];
+	bcc?: string[];
+	subject: string;
+	attachment_count: number;
+}
+
+export interface SendMessageResult {
+	from: string;
+	to: string[];
+	cc?: string[];
+	bcc?: string[];
+	subject: string;
+	attachment_count: number;
+	message_id?: string;
+	saved_to_mailbox?: string;
+	saved_uid?: string;
+}
+
+export interface MoveMessageResult {
+	uid: string;
+	source: string;
+	destination: string;
+}
+
+export interface ApplyLabelsResult {
+	uid: string;
+	mailbox: string;
+	labels: string[];
+	label_mailboxes: string[];
+}
+
 export type CommandContext = Pick<ExtensionCommandContext, "cwd" | "hasUI" | "ui">;
 
 export interface ToolContext {