stellamail 1.0.0

package/src/commands/flag.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const { getAccount } = require('../config');
+const { withImap } = require('../imap');
+const { chalk } = require('../format');
+
+const FLAG_MAP = {
+  seen: '\\Seen',
+  flagged: '\\Flagged',
+  answered: '\\Answered',
+  draft: '\\Draft'
+};
+
+async function run(opts, config) {
+  const id = opts._positional && opts._positional[0];
+  if (!id) {
+    console.error(chalk.red('❌ Usage: stellamail flag <id> --account <name> --add|--remove <flag>'));
+    process.exit(1);
+  }
+  if (!opts.account) {
+    console.error(chalk.red('❌ --account is required for flag'));
+    process.exit(1);
+  }
+  if (!opts.add && !opts.remove) {
+    console.error(chalk.red('❌ --add <flag> or --remove <flag> is required'));
+    console.error(chalk.gray('   Valid flags: seen, flagged, answered, draft'));
+    process.exit(1);
+  }
+
+  const acctConfig = getAccount(config, opts.account);
+  const folder = opts.folder || 'INBOX';
+  const seq = parseInt(id, 10);
+  const isJson = opts.output === 'json';
+
+  const flagName = opts.add || opts.remove;
+  const imapFlag = FLAG_MAP[flagName.toLowerCase()];
+  if (!imapFlag) {
+    console.error(chalk.red(`❌ Unknown flag: "${flagName}"`));
+    console.error(chalk.gray('   Valid flags: seen, flagged, answered, draft'));
+    process.exit(1);
+  }
+
+  const adding = !!opts.add;
+
+  await withImap(acctConfig, config, async (client) => {
+    const mailbox = await client.getMailboxLock(folder);
+    try {
+      if (adding) {
+        await client.messageFlagsAdd(String(seq), [imapFlag]);
+      } else {
+        await client.messageFlagsRemove(String(seq), [imapFlag]);
+      }
+
+      if (isJson) {
+        console.log(JSON.stringify({
+          status: 'updated',
+          id: seq,
+          folder,
+          action: adding ? 'added' : 'removed',
+          flag: flagName.toLowerCase(),
+          account: opts.account
+        }, null, 2));
+      } else {
+        const action = adding ? 'Added' : 'Removed';
+        console.log(chalk.green(`✅ ${action} flag "${flagName}" on message #${seq}`));
+      }
+    } finally {
+      mailbox.release();
+    }
+  });
+}
+
+const help = `
+stellamail flag — Toggle flags on a message
+
+USAGE:
+  stellamail flag <id> --account <name> --add|--remove <flag>
+
+REQUIRED:
+  <id>                Message sequence number
+  --account <name>    Account name from config
+  --add <flag>        Add a flag (seen, flagged, answered, draft)
+  --remove <flag>     Remove a flag
+
+OPTIONAL:
+  --folder <name>     Folder name (default INBOX)
+  --output json       Output as JSON
+  --config <path>     Path to config file
+
+EXAMPLES:
+  stellamail flag 142 --account work --add flagged
+  stellamail flag 142 --account work --remove seen
+`;
+
+module.exports = { run, help };

package/src/commands/folders.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { getAccount } = require('../config');
+const { withImap } = require('../imap');
+const { chalk } = require('../format');
+
+async function run(opts, config) {
+  if (!opts.account) {
+    console.error(chalk.red('❌ --account is required for folders'));
+    process.exit(1);
+  }
+
+  const acctConfig = getAccount(config, opts.account);
+  const isJson = opts.output === 'json';
+
+  await withImap(acctConfig, config, async (client) => {
+    const folders = await client.list();
+
+    if (isJson) {
+      const jsonFolders = [];
+      for (const f of folders) {
+        let messageCount = null;
+        try {
+          const status = await client.status(f.path, { messages: true });
+          messageCount = status.messages;
+        } catch (e) {}
+        jsonFolders.push({
+          path: f.path,
+          name: f.name || f.path,
+          messages: messageCount
+        });
+      }
+      console.log(JSON.stringify(jsonFolders, null, 2));
+      return;
+    }
+
+    console.log(chalk.cyan(`📁 Folders — ${opts.account}`));
+
+    const spamTrash = ['spam', 'trash', 'junk', '[gmail]/spam', '[gmail]/trash'];
+
+    for (let i = 0; i < folders.length; i++) {
+      const f = folders[i];
+      const isLast = i === folders.length - 1;
+      const prefix = isLast ? '└── ' : '├── ';
+
+      let countStr = '';
+      try {
+        const status = await client.status(f.path, { messages: true });
+        countStr = ` (${chalk.yellow(status.messages)})`;
+      } catch (e) {
+        countStr = '';
+      }
+
+      const folderPath = f.path;
+      const isInbox = folderPath.toUpperCase() === 'INBOX';
+      const isSpamTrash = spamTrash.includes(folderPath.toLowerCase());
+
+      let folderDisplay;
+      if (isInbox) {
+        folderDisplay = chalk.cyan.bold(folderPath);
+      } else if (isSpamTrash) {
+        folderDisplay = chalk.red(folderPath);
+      } else {
+        folderDisplay = chalk.cyan(folderPath);
+      }
+
+      console.log(`${chalk.gray(prefix)}${folderDisplay}${countStr}`);
+    }
+  });
+}
+
+const help = `
+stellamail folders — List mailbox folders
+
+USAGE:
+  stellamail folders --account <name> [options]
+
+OPTIONS:
+  --account <name>    Account name (required)
+  --output json       Output as JSON
+  --config <path>     Path to config file
+`;
+
+module.exports = { run, help };

package/src/commands/forward.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const fs = require('fs');
+const { simpleParser } = require('mailparser');
+const { getAccount } = require('../config');
+const { withImap } = require('../imap');
+const { getSignature } = require('../signature');
+const { validateAttachments, checkDuplicate } = require('../safety');
+const { logSend } = require('../logger');
+const { createTransport } = require('../smtp');
+const { chalk } = require('../format');
+
+async function run(opts, config) {
+  const id = opts._positional && opts._positional[0];
+  if (!id) {
+    console.error(chalk.red('❌ Usage: stellamail forward <id> --account <name> --to <email>'));
+    process.exit(1);
+  }
+  if (!opts.account) {
+    console.error(chalk.red('❌ --account is required for forward'));
+    process.exit(1);
+  }
+  if (!opts.to) {
+    console.error(chalk.red('❌ --to is required for forward'));
+    process.exit(1);
+  }
+
+  // Handle body-file
+  if (opts['body-file']) {
+    if (!fs.existsSync(opts['body-file'])) {
+      console.error(chalk.red(`❌ Body file not found: ${opts['body-file']}`));
+      process.exit(1);
+    }
+    opts.body = fs.readFileSync(opts['body-file'], 'utf8');
+  }
+
+  const acctConfig = getAccount(config, opts.account);
+  const folder = opts.folder || 'INBOX';
+  const seq = parseInt(id, 10);
+  const isJson = opts.output === 'json';
+
+  // Fetch original message via IMAP
+  const original = await withImap(acctConfig, config, async (client) => {
+    const mailbox = await client.getMailboxLock(folder);
+    try {
+      const msg = await client.fetchOne(String(seq), {
+        source: true,
+        envelope: true
+      });
+      return simpleParser(msg.source);
+    } finally {
+      mailbox.release();
+    }
+  });
+
+  // Build forward subject
+  const origSubject = original.subject || '';
+  const subject = /^fwd:/i.test(origSubject) ? origSubject : `Fwd: ${origSubject}`;
+  opts.subject = subject;
+
+  // Build forwarded body
+  const isHtml = !!opts.html;
+  const origFrom = original.from ? original.from.text : '';
+  const origTo = original.to ? original.to.text : '';
+  const origDate = original.date ? original.date.toISOString() : '';
+  const origText = original.text || original.html || '';
+
+  let fullBody;
+  const separator = '---------- Forwarded message ----------';
+  const fwdHeader = `From: ${origFrom}\nDate: ${origDate}\nSubject: ${origSubject}\nTo: ${origTo}`;
+
+  if (isHtml) {
+    const coverMsg = opts.body || '';
+    fullBody = coverMsg + '<br><br>' + separator + '<br>' +
+      fwdHeader.replace(/\n/g, '<br>') + '<br><br>' +
+      (original.html || origText);
+  } else {
+    const coverMsg = opts.body || '';
+    fullBody = coverMsg + '\n\n' + separator + '\n' +
+      fwdHeader + '\n\n' + origText;
+  }
+
+  // Signature
+  const signature = opts['no-signature'] ? '' : getSignature(acctConfig, config, isHtml);
+  const bodyWithSig = fullBody + signature;
+
+  // Gather attachments: original + additional
+  const origAttachments = (original.attachments || []).map(att => ({
+    filename: att.filename || 'attachment',
+    content: att.content,
+    contentType: att.contentType
+  }));
+
+  if (!opts.attachments) opts.attachments = [];
+  const additionalAttachments = opts.attachments.length
+    ? validateAttachments(opts.attachments, config)
+    : [];
+  const allAttachments = origAttachments.concat(additionalAttachments);
+
+  // Duplicate check
+  let lockFile = null;
+  if (!opts['no-duplicate-check']) {
+    const dup = checkDuplicate(opts, config);
+    lockFile = dup.lockFile;
+  }
+
+  // Build mail options
+  const mailOptions = {
+    from: acctConfig.from,
+    to: opts.to,
+    subject,
+    attachments: allAttachments
+  };
+  if (opts.cc) mailOptions.cc = opts.cc;
+  if (isHtml) {
+    mailOptions.html = bodyWithSig;
+  } else {
+    mailOptions.text = bodyWithSig;
+  }
+
+  // Dry run
+  if (opts['dry-run']) {
+    if (isJson) {
+      console.log(JSON.stringify({
+        dryRun: true,
+        from: mailOptions.from,
+        to: mailOptions.to,
+        cc: mailOptions.cc || null,
+        subject: mailOptions.subject,
+        format: isHtml ? 'html' : 'text',
+        attachments: allAttachments.map(a => a.filename),
+        bodyPreview: bodyWithSig.slice(0, 200)
+      }, null, 2));
+    } else {
+      console.log('🧪 DRY RUN — Forward would be sent:');
+      console.log(`   ${chalk.cyan('From:')}        ${mailOptions.from}`);
+      console.log(`   ${chalk.cyan('To:')}          ${mailOptions.to}`);
+      if (opts.cc) console.log(`   ${chalk.cyan('CC:')}          ${opts.cc}`);
+      console.log(`   ${chalk.cyan('Subject:')}     ${subject}`);
+      console.log(`   ${chalk.cyan('Format:')}      ${chalk.yellow(isHtml ? 'HTML' : 'Plain text')}`);
+      console.log(`   ${chalk.cyan('Attachments:')} ${allAttachments.length ? allAttachments.map(a => a.filename).join(', ') : 'none'}`);
+      console.log(`   ${chalk.cyan('Body preview:')}`);
+      console.log(chalk.gray('   ' + bodyWithSig.slice(0, 200).replace(/\n/g, '\n   ') + (bodyWithSig.length > 200 ? '...' : '')));
+    }
+    return;
+  }
+
+  // Write lock BEFORE sending
+  if (lockFile) {
+    fs.writeFileSync(lockFile, String(Math.floor(Date.now() / 1000)));
+  }
+
+  const transporter = createTransport(acctConfig, config);
+
+  try {
+    await transporter.verify();
+    if (!isJson) console.log(chalk.green('✅ SMTP connection verified'));
+  } catch (e) {
+    if (lockFile && fs.existsSync(lockFile)) fs.unlinkSync(lockFile);
+    console.error(chalk.red('❌ SMTP connection failed: ' + e.message));
+    process.exit(1);
+  }
+
+  try {
+    const info = await transporter.sendMail(mailOptions);
+
+    logSend({
+      timestamp: new Date().toISOString(),
+      account: opts.account,
+      to: opts.to,
+      cc: opts.cc || null,
+      subject,
+      attachments: allAttachments.map(a => a.filename),
+      messageId: info.messageId,
+      type: 'forward',
+      status: 'sent'
+    }, config);
+
+    if (isJson) {
+      console.log(JSON.stringify({
+        status: 'sent',
+        messageId: info.messageId,
+        to: opts.to,
+        cc: opts.cc || null,
+        subject,
+        type: 'forward'
+      }, null, 2));
+    } else {
+      console.log(chalk.green('✅ Forward sent successfully!'));
+      console.log(`   ${chalk.cyan('To:')}          ${opts.to}`);
+      if (opts.cc) console.log(`   ${chalk.cyan('CC:')}          ${opts.cc}`);
+      console.log(`   ${chalk.cyan('Subject:')}     ${subject}`);
+      console.log(`   ${chalk.cyan('Attachments:')} ${allAttachments.length ? allAttachments.map(a => a.filename).join(', ') : 'none'}`);
+      console.log(`   ${chalk.cyan('Message ID:')}  ${info.messageId}`);
+    }
+  } catch (e) {
+    logSend({
+      timestamp: new Date().toISOString(),
+      account: opts.account,
+      to: opts.to,
+      subject,
+      type: 'forward',
+      status: 'failed',
+      error: e.message
+    }, config);
+
+    console.error(chalk.red('❌ Forward FAILED: ' + e.message));
+    process.exit(1);
+  }
+}
+
+const help = `
+stellamail forward — Forward an email
+
+USAGE:
+  stellamail forward <id> --account <name> --to <email> [options]
+
+REQUIRED:
+  <id>                   Message sequence number
+  --account <name>       Account name from config
+  --to <email>           Recipient email address
+
+OPTIONAL:
+  --body <text>          Cover message
+  --body-file <path>     Read cover message from a file
+  --folder <name>        Folder name (default INBOX)
+  --cc <email>           CC recipient
+  --attachment <path>    Additional attachment (repeatable)
+  --html                 Treat body as HTML
+  --no-signature         Skip auto-appending signature
+  --no-duplicate-check   Skip duplicate blocking
+  --dry-run              Preview without sending
+  --output json          Output as JSON
+  --config <path>        Path to config file
+`;
+
+module.exports = { run, help };

package/src/commands/inbox.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const { getAccount } = require('../config');
+const { withImap } = require('../imap');
+const { formatDate, truncate, messageFlags, makeTable, chalk } = require('../format');
+
+async function run(opts, config) {
+  if (!opts.account) {
+    console.error(chalk.red('❌ --account is required for inbox'));
+    process.exit(1);
+  }
+
+  const acctConfig = getAccount(config, opts.account);
+  const folder = opts.folder || 'INBOX';
+  const limit = parseInt(opts.limit, 10) || 20;
+  const unreadOnly = !!opts.unread;
+  const isJson = opts.output === 'json';
+
+  await withImap(acctConfig, config, async (client) => {
+    const mailbox = await client.getMailboxLock(folder);
+    try {
+      const total = client.mailbox.exists;
+      let unreadCount = 0;
+
+      // Count unread
+      try {
+        const status = await client.status(folder, { unseen: true });
+        unreadCount = status.unseen || 0;
+      } catch (e) {
+        unreadCount = 0;
+      }
+
+      if (!isJson) {
+        const unreadLabel = unreadCount > 0 ? chalk.yellow.bold(`${unreadCount} unread`) : chalk.green.bold(`0 unread`);
+        console.log(chalk.cyan.bold(`\n  \uD83D\uDCEC Inbox`) + chalk.white.bold(` \u2014 ${opts.account}`) + chalk.gray(` (`) + unreadLabel + chalk.gray(`, ${total} total)`));
+        console.log();
+      }
+
+      if (total === 0) {
+        if (isJson) {
+          console.log(JSON.stringify([]));
+        } else {
+          console.log('   No messages.');
+        }
+        return;
+      }
+
+      const query = unreadOnly ? { seen: false } : { all: true };
+      const range = `${Math.max(1, total - limit + 1)}:${total}`;
+
+      const messages = [];
+      for await (const msg of client.fetch(range, {
+        envelope: true,
+        flags: true,
+        bodyStructure: true
+      })) {
+        messages.push(msg);
+      }
+
+      messages.sort((a, b) => b.seq - a.seq);
+
+      if (unreadOnly) {
+        messages.splice(0, messages.length, ...messages.filter(m => !m.flags.has('\\Seen')));
+      }
+
+      const display = messages.slice(0, limit);
+
+      if (isJson) {
+        const jsonMessages = display.map(msg => {
+          const env = msg.envelope;
+          const from = env.from && env.from[0]
+            ? { name: env.from[0].name || null, address: env.from[0].address || null }
+            : null;
+          const hasAttach = msg.bodyStructure && msg.bodyStructure.type === 'multipart';
+          return {
+            seq: msg.seq,
+            subject: env.subject || null,
+            from,
+            date: env.date ? new Date(env.date).toISOString() : null,
+            flags: Array.from(msg.flags || []),
+            hasAttachment: hasAttach
+          };
+        });
+        console.log(JSON.stringify(jsonMessages, null, 2));
+        return;
+      }
+
+      const table = makeTable(['#', 'FLAGS', 'SUBJECT', 'FROM', 'DATE'], [6, 8, 35, 25, 18]);
+
+      for (const msg of display) {
+        const env = msg.envelope;
+        const from = env.from && env.from[0]
+          ? (env.from[0].name || env.from[0].address || '')
+          : '';
+        const hasAttach = msg.bodyStructure && msg.bodyStructure.type === 'multipart';
+        const flags = messageFlags(msg.flags, hasAttach);
+        const isUnread = msg.flags && !msg.flags.has('\\Seen');
+
+        const numColor = isUnread ? chalk.cyan.bold : chalk.white;
+        const subjColor = isUnread ? chalk.white.bold : chalk.white;
+        const fromColor = isUnread ? chalk.green.bold : chalk.green;
+        const dateColor = isUnread ? chalk.yellow.bold : chalk.yellow;
+
+        table.push([
+          numColor(String(msg.seq)),
+          flags,
+          subjColor(truncate(env.subject || '(no subject)', 33)),
+          fromColor(truncate(from, 23)),
+          dateColor(formatDate(env.date))
+        ]);
+      }
+
+      console.log(table.toString());
+    } finally {
+      mailbox.release();
+    }
+  });
+}
+
+const help = `
+stellamail inbox — List inbox messages
+
+USAGE:
+  stellamail inbox --account <name> [options]
+
+OPTIONS:
+  --account <name>    Account name (required)
+  --limit <n>         Number of messages (default 20)
+  --folder <name>     Folder name (default INBOX)
+  --unread            Only show unread messages
+  --output json       Output as JSON
+  --config <path>     Path to config file
+`;
+
+module.exports = { run, help };