@prismatic-io/components-imap 0.0.0-stage → 0.0.1

package/npm-dist/index.cjs

@@ -0,0 +1,933 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let imapflow = require("imapflow");
+let mailparser = require("mailparser");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+//#region src/connections/index.ts
+const imapConnection = (0, _prismatic_io_spectral.onPremConnection)({
+	key: "imap",
+	display: {
+		label: "IMAP Connection",
+		description: "Provide the details of your IMAP server."
+	},
+	inputs: {
+		host: {
+			label: "Host",
+			placeholder: "Host",
+			type: "string",
+			required: true,
+			clean: (param) => _prismatic_io_spectral.util.types.toString(param) || void 0,
+			shown: true,
+			comments: "Provide the host address for the desired IMAP server.",
+			example: "imap.example.com",
+			onPremControlled: true
+		},
+		port: {
+			label: "Port",
+			placeholder: "Port",
+			type: "string",
+			required: true,
+			clean: (param) => _prismatic_io_spectral.util.types.toNumber(param) || void 0,
+			shown: true,
+			comments: "Provide the port for the desired IMAP server.",
+			example: "993",
+			default: "993",
+			onPremControlled: true
+		},
+		secure: {
+			label: "Secure",
+			placeholder: "Secure",
+			type: "boolean",
+			clean: (param) => _prismatic_io_spectral.util.types.toBool(param) || void 0,
+			required: true,
+			shown: true,
+			default: "true",
+			comments: "Determines if the connection is secure."
+		},
+		user: {
+			label: "Username",
+			placeholder: "Username",
+			type: "string",
+			clean: (param) => _prismatic_io_spectral.util.types.toString(param) || void 0,
+			required: true,
+			shown: true,
+			comments: "Provide a valid username or email.",
+			example: "someone@example.com"
+		},
+		pass: {
+			label: "Password",
+			placeholder: "Password",
+			type: "password",
+			required: false,
+			shown: true,
+			clean: (param) => _prismatic_io_spectral.util.types.toString(param) || void 0,
+			comments: "Provide the password for the given user. This value is required if secured is set to true.",
+			example: "examplePassword"
+		},
+		minVersion: {
+			label: "Minimum TLS Version",
+			type: "string",
+			required: true,
+			shown: true,
+			clean: (param) => _prismatic_io_spectral.util.types.toString(param) || void 0,
+			comments: "Provide a valid TLS version to be used in the connection.",
+			example: "TLSv1.1",
+			default: "TLSv1.1",
+			model: [
+				{
+					label: "TLSv1.1",
+					value: "TLSv1.1"
+				},
+				{
+					label: "TLSv1.2",
+					value: "TLSv1.2"
+				},
+				{
+					label: "TLSv1.3",
+					value: "TLSv1.3"
+				}
+			]
+		},
+		maxVersion: {
+			label: "Maximum TLS Version",
+			type: "string",
+			required: true,
+			shown: true,
+			clean: (param) => _prismatic_io_spectral.util.types.toString(param) || void 0,
+			comments: "Provide a valid TLS version to be used in the connection.",
+			example: "TLSv1.3",
+			default: "TLSv1.3",
+			model: [
+				{
+					label: "TLSv1.1",
+					value: "TLSv1.1"
+				},
+				{
+					label: "TLSv1.2",
+					value: "TLSv1.2"
+				},
+				{
+					label: "TLSv1.3",
+					value: "TLSv1.3"
+				}
+			]
+		},
+		minDHSize: {
+			label: "Min DH Size",
+			type: "string",
+			required: true,
+			shown: true,
+			clean: (param) => _prismatic_io_spectral.util.types.toInt(param) || void 0,
+			comments: "Minimum size of bits to accept in a TLS connection",
+			example: "512",
+			default: "1024"
+		}
+	}
+});
+var connections_default = [imapConnection];
+//#endregion
+//#region src/client.ts
+const createClient = (connection, debug) => {
+	if (connection.key !== imapConnection.key) throw new _prismatic_io_spectral.ConnectionError(connection, `Unsupported connection provided: ${connection.key}`);
+	return new imapflow.ImapFlow({
+		host: _prismatic_io_spectral.util.types.toString(connection.fields.host),
+		port: _prismatic_io_spectral.util.types.toNumber(connection.fields.port),
+		secure: _prismatic_io_spectral.util.types.toBool(connection.fields.secure),
+		auth: {
+			user: _prismatic_io_spectral.util.types.toString(connection.fields.user),
+			pass: _prismatic_io_spectral.util.types.toString(connection.fields.pass)
+		},
+		tls: {
+			minDHSize: _prismatic_io_spectral.util.types.toInt(connection.fields.minDHSize),
+			rejectUnauthorized: true,
+			minVersion: _prismatic_io_spectral.util.types.toString(connection.fields.minVersion),
+			maxVersion: _prismatic_io_spectral.util.types.toString(connection.fields.maxVersion),
+			ciphers: "ALL"
+		},
+		logger: debug ? console : false
+	});
+};
+//#endregion
+//#region src/examplePayloads.ts
+const addFlagsExamplePayload = { data: true };
+const appendMessageExamplePayload = { data: {
+	destination: "INBOX",
+	uid: 456,
+	uidValidity: "596391842",
+	seq: 61
+} };
+const copyMessageExamplePayload = { data: {
+	path: "My-Source-Mailbox",
+	destination: "My-Destination-Mailbox",
+	uidValidity: "596391920",
+	uidMap: /* @__PURE__ */ new Map([[1, 2]])
+} };
+const createMailboxExamplePayload = { data: {
+	path: "New-Mailbox",
+	created: true
+} };
+const deleteMessageExamplePayload = { data: true };
+const downloadMessageExamplePayload = { data: {
+	meta: {
+		expectedSize: 12345,
+		contentType: "message/rfc822"
+	},
+	message: {
+		headers: {
+			from: { value: [{
+				address: "sender@example.com",
+				name: "Sender"
+			}] },
+			to: { value: [{
+				address: "recipient@example.com",
+				name: "Recipient"
+			}] },
+			subject: "Example Subject",
+			date: "2025-07-21T12:00:00.000Z"
+		},
+		attachments: [],
+		attachmentsMetadata: [],
+		text: "This is the plain text body of the email.",
+		html: "<p>This is the HTML body of the email.</p>"
+	}
+} };
+const getStatusExamplePayload = { data: {
+	path: "INBOX",
+	highestModseq: "10914782",
+	messages: 61,
+	recent: 0,
+	uidNext: 76791,
+	uidValidity: "596391842",
+	unseen: 41
+} };
+const listMailboxesExamplePayload = { data: [
+	{
+		path: "Drafts",
+		flags: /* @__PURE__ */ new Set(),
+		delimiter: "/",
+		listed: true,
+		name: "Drafts",
+		subscribed: true
+	},
+	{
+		path: "INBOX",
+		flags: /* @__PURE__ */ new Set(),
+		delimiter: "/",
+		listed: true,
+		specialUse: "\\Inbox",
+		name: "INBOX",
+		subscribed: true
+	},
+	{
+		path: "Sent",
+		flags: /* @__PURE__ */ new Set(),
+		delimiter: "/",
+		listed: true,
+		name: "Sent",
+		subscribed: true
+	}
+] };
+const removeFlagsExamplePayload = { data: true };
+const renameMailboxExamplePayload = { data: {
+	path: "Old-Mailbox",
+	newPath: "New-Mailbox"
+} };
+const searchMailboxExamplePayload = { data: [
+	1,
+	5,
+	12,
+	45,
+	78
+] };
+const setFlagsExamplePayload = { data: true };
+//#endregion
+//#region src/inputs/general.ts
+const connection = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The IMAP connection to use."
+});
+const mailbox = (0, _prismatic_io_spectral.input)({
+	label: "Mailbox",
+	type: "string",
+	required: true,
+	comments: "Provide a string value for the name of the mailbox.",
+	example: "INBOX",
+	placeholder: "Enter mailbox name",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const path = (0, _prismatic_io_spectral.input)({
+	label: "Path",
+	type: "string",
+	required: true,
+	comments: "Mailbox path to upload the message to.",
+	example: "INBOX",
+	placeholder: "Enter mailbox path",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const range = (0, _prismatic_io_spectral.input)({
+	label: "Range",
+	type: "string",
+	required: true,
+	comments: "Provide a range of messages. Alternatively you can specify * to get the latest message.",
+	example: "1,2,4:6",
+	placeholder: "Enter message range",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const flags = (0, _prismatic_io_spectral.input)({
+	label: "Flags",
+	type: "string",
+	required: true,
+	collection: "valuelist",
+	comments: "For each item, provide a string value to be added to an existing message.",
+	example: "exampleFlag",
+	placeholder: "Enter flag value",
+	clean: (value) => value
+});
+const content = (0, _prismatic_io_spectral.input)({
+	label: "Message Content",
+	type: "string",
+	required: true,
+	comments: "The raw RFC 822 formatted message content to append.",
+	example: `
+  From: someone@<yourcompany>.com
+  Subject: A basic RFC 850 formatted message
+  Newsgroups: comp.<yourcompany>.test
+
+  The body of this message is plain text. Note the blank line
+  between the header information and the body of the message.
+  `,
+	placeholder: "Enter message content",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const messageIndex = (0, _prismatic_io_spectral.input)({
+	label: "Message UID",
+	type: "string",
+	required: true,
+	example: "5",
+	comments: "The UID of the message.",
+	placeholder: "Enter message UID",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+//#endregion
+//#region src/inputs/actions.ts
+const from = (0, _prismatic_io_spectral.input)({
+	label: "From",
+	type: "string",
+	required: false,
+	comments: "Filter email messages by sender.",
+	example: "someone@example.com",
+	placeholder: "Enter sender email address",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const to = (0, _prismatic_io_spectral.input)({
+	label: "To",
+	type: "string",
+	required: false,
+	comments: "Filter email messages by recipient.",
+	example: "someone@example.com",
+	placeholder: "Enter recipient email address",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const readUnread = (0, _prismatic_io_spectral.input)({
+	label: "Read / Unread Filter",
+	type: "string",
+	required: true,
+	default: "all",
+	comments: "Filter messages by read or unread status.",
+	model: [
+		{
+			label: "Show all messages",
+			value: "all"
+		},
+		{
+			label: "Show only unread messages",
+			value: "unread"
+		},
+		{
+			label: "Show only read messages",
+			value: "read"
+		}
+	],
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const filterOptions = (0, _prismatic_io_spectral.input)({
+	label: "Filter Options",
+	type: "code",
+	language: "json",
+	required: false,
+	comments: "Extra parameters to filter the search results.",
+	placeholder: "Enter filter options as JSON",
+	example: JSON.stringify({
+		recent: true,
+		subject: "example",
+		from: "someone@example.com",
+		to: "someone@example.com",
+		since: "2025-01-01",
+		before: "2025-01-01"
+	}, null, 2),
+	clean: _prismatic_io_spectral.util.types.toObject
+});
+const addFlagsInputs = {
+	connection,
+	mailbox,
+	range,
+	flags
+};
+const appendMessageInputs = {
+	connection,
+	mailbox,
+	path,
+	content
+};
+const copyMessageInputs = {
+	connection,
+	mailbox,
+	range,
+	path: {
+		...path,
+		label: "New Path"
+	}
+};
+const createMailboxInputs = {
+	connection,
+	path
+};
+const deleteMessageInputs = {
+	connection,
+	mailbox,
+	messageIndex
+};
+const downloadMessageInputs = {
+	connection,
+	mailbox,
+	messageIndex: {
+		...messageIndex,
+		label: "Message Index or ID",
+		comments: "The index of the message you would like to download (1 for the oldest message, 2 for second oldest, etc), or the ID of the message."
+	}
+};
+const getStatusInputs = {
+	connection,
+	mailbox
+};
+const listMailboxesInputs = { connection };
+const removeFlagsInputs = {
+	connection,
+	mailbox,
+	range,
+	flags
+};
+const renameMailboxInputs = {
+	connection,
+	path,
+	newPath: {
+		...path,
+		label: "New Path"
+	}
+};
+const searchMailboxInputs = {
+	connection,
+	mailbox,
+	from,
+	to,
+	readUnread,
+	filterOptions
+};
+const setFlagsInputs = {
+	connection,
+	mailbox,
+	range,
+	flags
+};
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	listMailboxes: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Mailboxes",
+			description: "Returns a list of available mailboxes"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				return { data: await client.list() };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: listMailboxesInputs,
+		examplePayload: listMailboxesExamplePayload
+	}),
+	getStatus: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Mailbox Status",
+			description: "Returns the status of a mailbox's properties"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				const status = await client.status(_prismatic_io_spectral.util.types.toString(params.mailbox), {
+					unseen: true,
+					messages: true,
+					highestModseq: true,
+					recent: true,
+					uidNext: true,
+					uidValidity: true
+				});
+				return { data: JSON.parse(JSON.stringify(status, (_key, value) => typeof value === "bigint" ? value.toString() : value)) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: getStatusInputs,
+		examplePayload: getStatusExamplePayload
+	}),
+	addFlags: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Add Flags",
+			description: "Add new flags to an existing message"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				await client.mailboxOpen(_prismatic_io_spectral.util.types.toString(params.mailbox));
+				return { data: await client.messageFlagsAdd(_prismatic_io_spectral.util.types.toString(params.range), params.flags.map((flag) => _prismatic_io_spectral.util.types.toString(flag)), { uid: true }) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: addFlagsInputs,
+		examplePayload: addFlagsExamplePayload
+	}),
+	appendMessage: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Append Message",
+			description: "Appends a new message to an existing mailbox"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				const data = await client.append(_prismatic_io_spectral.util.types.toString(params.path), Buffer.from(_prismatic_io_spectral.util.types.toString(params.content)));
+				return { data: JSON.parse(JSON.stringify(data, (_key, value) => typeof value === "bigint" ? value.toString() : value)) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: appendMessageInputs,
+		examplePayload: appendMessageExamplePayload
+	}),
+	copyMessage: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Copy Message",
+			description: "Copies a message from one mailbox to another."
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				await client.mailboxOpen(_prismatic_io_spectral.util.types.toString(params.mailbox));
+				const data = await client.messageCopy(_prismatic_io_spectral.util.types.toString(params.range), _prismatic_io_spectral.util.types.toString(params.path), { uid: true });
+				if (data) return { data: {
+					...data,
+					uidValidity: data.uidValidity?.toString()
+				} };
+				else throw new Error("An error occurred copying the message. Check your message ID and that your destination inbox exists.");
+			} finally {
+				client.close();
+			}
+		},
+		examplePayload: copyMessageExamplePayload,
+		inputs: copyMessageInputs
+	}),
+	createMailbox: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create Mailbox",
+			description: "Creates a new mailbox folder and sets up subscription for the created mailbox"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				return { data: await client.mailboxCreate(_prismatic_io_spectral.util.types.toString(params.path)) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: createMailboxInputs,
+		examplePayload: createMailboxExamplePayload
+	}),
+	deleteMessage: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Message",
+			description: "Delete an existing message"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				await client.mailboxOpen(_prismatic_io_spectral.util.types.toString(params.mailbox));
+				return { data: await client.messageDelete(_prismatic_io_spectral.util.types.toString(params.messageIndex), { uid: true }) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: deleteMessageInputs,
+		examplePayload: deleteMessageExamplePayload
+	}),
+	downloadMessage: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Download Message",
+			description: "Download either full RFC-822 formatted message or a specific body structure part"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				await client.getMailboxLock(_prismatic_io_spectral.util.types.toString(params.mailbox));
+				const { content, meta } = await client.download(params.messageIndex, "", { uid: true });
+				const parsed = await (0, mailparser.simpleParser)(content, {
+					writableObjectMode: true,
+					autoDestroy: true
+				});
+				return { data: {
+					meta,
+					message: {
+						headers: Object.fromEntries(parsed.headers),
+						attachments: parsed.attachments.map(({ contentType, content }) => ({ file: {
+							contentType,
+							data: content
+						} })),
+						attachmentsMetadata: parsed.attachments.map(({ filename, size, checksum, headers, related }) => ({
+							filename,
+							size,
+							checksum,
+							headers,
+							related
+						})),
+						text: parsed.text,
+						html: parsed.html
+					}
+				} };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: downloadMessageInputs,
+		examplePayload: downloadMessageExamplePayload
+	}),
+	removeFlags: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Remove Flags From Message",
+			description: "Remove existing flags from an existing message"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				await client.mailboxOpen(_prismatic_io_spectral.util.types.toString(params.mailbox));
+				return { data: await client.messageFlagsRemove(_prismatic_io_spectral.util.types.toString(params.range), params.flags.map((flag) => _prismatic_io_spectral.util.types.toString(flag)), { uid: true }) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: removeFlagsInputs,
+		examplePayload: removeFlagsExamplePayload
+	}),
+	renameMailbox: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Rename Mailbox",
+			description: "Change the name of an existing mailbox"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				return { data: await client.mailboxRename(_prismatic_io_spectral.util.types.toString(params.path), _prismatic_io_spectral.util.types.toString(params.newPath)) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: renameMailboxInputs,
+		examplePayload: renameMailboxExamplePayload
+	}),
+	searchMailbox: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Search / List Mailbox Messages",
+			description: "Returns all messages in the given mailbox"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				await client.getMailboxLock(_prismatic_io_spectral.util.types.toString(params.mailbox));
+				const options = {
+					from: _prismatic_io_spectral.util.types.toString(params.from) || void 0,
+					to: _prismatic_io_spectral.util.types.toString(params.to) || void 0,
+					...params.filterOptions
+				};
+				if (params.readUnread === "unread") options.seen = false;
+				if (params.readUnread === "read") options.seen = true;
+				if (params.readUnread === "all") options.all = true;
+				return { data: await client.search(options, { uid: true }) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: searchMailboxInputs,
+		examplePayload: searchMailboxExamplePayload
+	}),
+	setFlags: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Set Flags",
+			description: "Set a value for an existing message flag"
+		},
+		perform: async (context, params) => {
+			const client = createClient(params.connection, context.debug.enabled);
+			await client.connect();
+			try {
+				return { data: await client.messageFlagsSet(_prismatic_io_spectral.util.types.toString(params.range), params.flags.map((flag) => _prismatic_io_spectral.util.types.toString(flag)), { uid: true }) };
+			} finally {
+				client.close();
+			}
+		},
+		inputs: setFlagsInputs,
+		examplePayload: setFlagsExamplePayload
+	})
+};
+//#endregion
+//#region src/inputs/dataSources.ts
+const listMailboxesDataSourceInputs = { connection };
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = { listMailboxes: (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "List Mailboxes",
+		description: "Returns a picklist of available mailboxes that users can choose from"
+	},
+	dataSourceType: "picklist",
+	perform: async (_context, params) => {
+		const client = createClient(params.connection, false);
+		await client.connect();
+		try {
+			return { result: (await client.list()).map((mailbox) => ({
+				key: mailbox.path,
+				label: mailbox.name
+			})) };
+		} finally {
+			client.close();
+		}
+	},
+	inputs: listMailboxesDataSourceInputs
+}) };
+//#endregion
+//#region src/constants.ts
+const LOOK_BACK_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+//#endregion
+//#region src/util/polling.ts
+const lookBackDateClean = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim();
+	if (!str) return "";
+	if (!LOOK_BACK_DATE_PATTERN.test(str)) throw new Error("Look-back Date must be in YYYY-MM-DD format.");
+	const parts = str.split("-");
+	const year = _prismatic_io_spectral.util.types.toNumber(parts[0]);
+	const month = _prismatic_io_spectral.util.types.toNumber(parts[1]);
+	const day = _prismatic_io_spectral.util.types.toNumber(parts[2]);
+	const parsed = new Date(year, month - 1, day);
+	if (parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) throw new Error(`Look-back Date "${str}" is not a valid calendar date.`);
+	if (parsed > /* @__PURE__ */ new Date()) throw new Error("Look-back Date cannot be a future date.");
+	return str;
+};
+const resolveImapRecordChanges = (data) => {
+	if (!data || !Array.isArray(data)) return [];
+	return data.map((record) => ({
+		changeType: "created",
+		record
+	}));
+};
+//#endregion
+//#region src/inputs/triggers.ts
+const fetchContent = (0, _prismatic_io_spectral.input)({
+	label: "Fetch Content",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When enabled, downloads and parses the full message body for each new email.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const markAsRead = (0, _prismatic_io_spectral.input)({
+	label: "Mark as Read",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When enabled, sets the Seen flag on new emails after polling.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const newEmailsPollingTriggerInputs = {
+	connection,
+	mailbox,
+	lookBackDate: (0, _prismatic_io_spectral.input)({
+		label: "Look-back Date",
+		placeholder: "Enter look-back date (YYYY-MM-DD)",
+		type: "string",
+		required: false,
+		comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync delivers each email received on or after this date once.",
+		example: "2026-01-01",
+		clean: lookBackDateClean
+	}),
+	fetchContent,
+	markAsRead
+};
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = { newEmailsPollingTrigger: (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New Emails",
+		description: "Retrieves existing and new emails for a specified IMAP mailbox. Load history once, check for changes on a schedule, or both."
+	},
+	inputs: newEmailsPollingTriggerInputs,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: { resolveItems: (_context, { payload }) => resolveImapRecordChanges(payload.body.data) },
+	perform: async (context, payload, { connection, fetchContent, mailbox, markAsRead, lookBackDate }) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const client = createClient(connection, context.debug.enabled);
+		await client.connect();
+		try {
+			const mailboxName = mailbox;
+			const status = await client.status(mailboxName, {
+				uidNext: true,
+				uidValidity: true,
+				messages: true,
+				recent: true,
+				unseen: true,
+				highestModseq: true
+			});
+			const currentUidNext = status.uidNext ?? 0;
+			const currentUidValidity = typeof status.uidValidity === "bigint" ? _prismatic_io_spectral.util.types.toString(status.uidValidity) : _prismatic_io_spectral.util.types.toString(status.uidValidity ?? "");
+			const state = context.polling.getState();
+			const isFirstPoll = !state.lastUidNext || state.uidValidity !== currentUidValidity;
+			if (isFirstPoll && !lookBackDate) {
+				context.polling.setState({
+					lastUidNext: currentUidNext,
+					uidValidity: currentUidValidity,
+					lastPolledAt: now
+				});
+				return {
+					payload: {
+						...payload,
+						body: { data: [] }
+					},
+					polledNoChanges: true
+				};
+			}
+			if (state.lastUidNext !== void 0 && currentUidNext <= state.lastUidNext) {
+				context.polling.setState({
+					...state,
+					lastPolledAt: now
+				});
+				return {
+					payload: {
+						...payload,
+						body: { data: [] }
+					},
+					polledNoChanges: true
+				};
+			}
+			await client.getMailboxLock(mailboxName);
+			const shouldFetchContent = fetchContent;
+			const shouldMarkAsRead = markAsRead;
+			let uidRange;
+			if (isFirstPoll && lookBackDate) {
+				const searchDate = new Date(lookBackDate);
+				const uids = await client.search({ since: searchDate }, { uid: true });
+				if (!uids || uids.length === 0) {
+					context.polling.setState({
+						lastUidNext: currentUidNext,
+						uidValidity: currentUidValidity,
+						lastPolledAt: now
+					});
+					return {
+						payload: {
+							...payload,
+							body: { data: [] }
+						},
+						polledNoChanges: true
+					};
+				}
+				uidRange = `${Math.min(...uids)}:*`;
+			} else uidRange = `${state.lastUidNext}:*`;
+			const rawMessages = [];
+			for await (const message of client.fetch(uidRange, {
+				uid: true,
+				envelope: true,
+				flags: true,
+				internalDate: true,
+				size: true,
+				source: shouldFetchContent
+			}, { uid: true })) rawMessages.push(message);
+			const emails = await Promise.all(rawMessages.map(async (message) => {
+				const email = {
+					uid: message.uid,
+					envelope: message.envelope,
+					flags: [...message.flags ?? []],
+					internalDate: message.internalDate,
+					size: message.size
+				};
+				if (shouldFetchContent && message.source) {
+					const parsed = await (0, mailparser.simpleParser)(message.source);
+					email.text = parsed.text;
+					email.html = parsed.html;
+					email.attachments = parsed.attachments.map(({ filename, size, contentType }) => ({
+						filename,
+						size,
+						contentType
+					}));
+				}
+				return email;
+			}));
+			if (shouldMarkAsRead && emails.length > 0) await client.messageFlagsAdd(uidRange, ["\\Seen"], { uid: true });
+			context.polling.setState({
+				lastUidNext: currentUidNext,
+				uidValidity: currentUidValidity,
+				lastPolledAt: now
+			});
+			return {
+				payload: {
+					...payload,
+					body: { data: emails }
+				},
+				polledNoChanges: emails.length === 0
+			};
+		} finally {
+			client.close();
+		}
+	}
+}) };
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "imap",
+	public: true,
+	documentationUrl: "https://prismatic.io/docs/components/imap/",
+	display: {
+		category: "Application Connectors",
+		label: "IMAP",
+		description: "Interact with your IMAP email account",
+		iconPath: "icon.png"
+	},
+	hooks: { error: _prismatic_io_spectral_http.handleErrors },
+	actions: actions_default,
+	triggers: triggers_default,
+	dataSources: dataSources_default,
+	connections: connections_default
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;