dooray-mail-cli 0.1.0

package/README.md

@@ -0,0 +1,19 @@
+# Dooray OpenClaw Skill
+
+Dooray mail CLI for OpenClaw - IMAP/SMTP integration
+
+## Installation
+
+```bash
+npm install -g .
+```
+
+## Usage
+
+```bash
+dooray-cli config  # Setup
+dooray-cli recent  # List recent mails
+dooray-cli test    # Test connection
+```
+
+See `SKILL.md` for OpenClaw integration.

package/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: dooray
+description: "Manage Dooray emails via IMAP/SMTP using the dooray-cli command. List, read, send, and search emails from the terminal. Use when working with Dooray email, checking Dooray inbox, or when the user mentions Dooray mail operations."
+homepage: https://dooray.com
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "📧",
+        "requires": { "bins": ["dooray-cli"] },
+        "install":
+          [
+            {
+              "id": "npm-global",
+              "kind": "npm",
+              "package": "dooray-mail-cli",
+              "bins": ["dooray-cli"],
+              "label": "Install Dooray CLI (npm)",
+            },
+          ],
+      },
+  }
+---
+
+# Dooray Email CLI
+
+Dooray CLI is a command-line tool for managing Dooray emails using IMAP/SMTP protocols.
+
+## Prerequisites
+
+1. Dooray CLI installed (`dooray-cli --help` to verify)
+2. Dooray email account with IMAP/SMTP access enabled
+3. Configuration file setup (created via `dooray-cli config`)
+
+## Configuration Setup
+
+Run the interactive configuration wizard:
+
+```bash
+dooray-cli config
+```
+
+This will:
+- Prompt for your Dooray email address
+- Securely encrypt and store your password
+- Save configuration to `~/.dooray-config.json`
+
+**Default Dooray IMAP/SMTP settings:**
+- IMAP: `imap.dooray.com:993` (SSL)
+- SMTP: `smtp.dooray.com:465` (SSL)
+
+## Common Operations
+
+### List Recent Emails (All)
+
+List 10 most recent emails (read and unread):
+
+```bash
+dooray-cli recent
+```
+
+Output format:
+```
+📬 Recent Mails (10)
+
+1. ✓ [UID: 279] sender@example.com <sender@example.com>
+   Subject: Project Update
+   Date: 2026-02-09T08:29:51.000Z
+
+2. ✓ [UID: 278] John Doe <john.doe@example.com>
+   Subject: Meeting Schedule - 02.12(Thu) 03:30 PM
+   Date: 2026-02-09T07:00:47.000Z
+```
+
+**✓** = Read, **●** = Unread
+
+### List Unread Emails Only
+
+List up to 10 most recent unread emails:
+
+```bash
+dooray-cli list
+```
+
+Output format:
+```
+📬 Unread Mails (3)
+
+1. [UID: 123] sender@example.com <sender@example.com>
+   Subject: Project Update
+   Date: 2026-02-09T10:30:00.000Z
+
+2. [UID: 124] colleague@example.com <colleague@example.com>
+   Subject: Meeting Notes
+   Date: 2026-02-09T11:15:00.000Z
+```
+
+### Read a Specific Email
+
+Read email by UID (from list output):
+
+```bash
+dooray-cli read 123
+```
+
+### Send a New Email
+
+**Non-interactive (recommended for automation):**
+
+```bash
+dooray-cli send --to "recipient@example.com" --subject "Subject here" --body "Message body here"
+```
+
+**Interactive mode:**
+
+```bash
+dooray-cli send
+```
+
+You'll be prompted for:
+- To: recipient email address
+- Subject: email subject
+- Body: email content (press Ctrl+D when done)
+
+### Search Emails
+
+Search for emails by keywords in subject:
+
+```bash
+dooray-cli search "meeting"
+dooray-cli search "project" "update"
+```
+
+### Check Unread Count
+
+Get total unread email count:
+
+```bash
+dooray-cli unread
+```
+
+Output: `📬 Unread mails: 5`
+
+### Test Connection
+
+Verify IMAP/SMTP connection:
+
+```bash
+dooray-cli test
+```
+
+## Output Formats
+
+All commands output to stdout with emoji indicators:
+
+- `✅` Success
+- `❌` Error
+- `📬` Unread mail info
+- `📧` Mail details
+- `🔍` Search results
+
+## Error Handling
+
+Common errors:
+
+**Configuration not found:**
+```
+❌ Configuration not found. Run: dooray-cli config
+```
+Solution: Run `dooray-cli config` to set up credentials.
+
+**Connection failed:**
+```
+❌ IMAP connection failed
+```
+Solution: Check network, verify credentials, or run `dooray-cli test`.
+
+**Invalid UID:**
+```
+❌ Usage: dooray-cli read <uid>
+```
+Solution: Use `dooray-cli list` to get valid UIDs.
+
+## Tips
+
+- UIDs are relative to the inbox folder
+- Password is encrypted using AES-256 and stored locally
+- Configuration file: `~/.dooray-config.json` (Windows: `%USERPROFILE%\.dooray-config.json`)
+- Run `dooray-cli help` for quick reference
+
+## Security Notes
+
+- Never share your `.dooray-config.json` file
+- Password is encrypted but stored on local filesystem
+- Use app-specific passwords if 2FA is enabled on Dooray account

package/dist/mail-client.js

@@ -0,0 +1,381 @@
+"use strict";
+/**
+ * Dooray Mail Client (IMAP/SMTP)
+ *
+ * IMAP/SMTP 프로토콜을 사용하여 Dooray 메일과 통신합니다.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoorayMailClient = void 0;
+const nodemailer = __importStar(require("nodemailer"));
+const imaps = __importStar(require("imap-simple"));
+const mailparser_1 = require("mailparser");
+class DoorayMailClient {
+    constructor(config) {
+        this.config = config;
+        // SMTP 설정
+        this.smtpTransporter = nodemailer.createTransport({
+            host: config.smtp.host,
+            port: config.smtp.port,
+            secure: config.smtp.secure,
+            auth: {
+                user: config.email,
+                pass: config.password
+            },
+            tls: {
+                rejectUnauthorized: false // Dooray SSL 인증서 문제 해결
+            }
+        });
+    }
+    /**
+     * IMAP 연결 생성
+     */
+    async getImapConnection() {
+        const imapConfig = {
+            imap: {
+                user: this.config.email,
+                password: this.config.password,
+                host: this.config.imap.host,
+                port: this.config.imap.port,
+                tls: this.config.imap.secure,
+                tlsOptions: {
+                    rejectUnauthorized: false
+                },
+                authTimeout: 30000
+            }
+        };
+        try {
+            const connection = await imaps.connect(imapConfig);
+            return connection;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray IMAP] Connection failed:', err.message);
+            throw new Error(`IMAP 연결 실패: ${err.message}`);
+        }
+    }
+    /**
+     * 읽지 않은 메일 개수
+     */
+    async getUnreadCount() {
+        let connection;
+        try {
+            connection = await this.getImapConnection();
+            await connection.openBox('INBOX');
+            const searchCriteria = ['UNSEEN'];
+            const fetchOptions = {
+                bodies: [''],
+                struct: true
+            };
+            const messages = await connection.search(searchCriteria, fetchOptions);
+            connection.end();
+            return messages.length;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to get unread count:', err.message);
+            if (connection)
+                connection.end();
+            return 0;
+        }
+    }
+    /**
+     * 읽지 않은 메일 목록
+     */
+    async getUnreadMail(limit = 10) {
+        let connection;
+        try {
+            connection = await this.getImapConnection();
+            await connection.openBox('INBOX');
+            const searchCriteria = ['UNSEEN'];
+            const fetchOptions = {
+                bodies: ['HEADER', 'TEXT', ''],
+                struct: true,
+                markSeen: false
+            };
+            const messages = await connection.search(searchCriteria, fetchOptions);
+            // 최신 메일부터 limit개만
+            const limitedMessages = messages.slice(0, limit);
+            const parsedMails = [];
+            for (const item of limitedMessages) {
+                const mail = await this.parseImapMessage(item);
+                if (mail)
+                    parsedMails.push(mail);
+            }
+            connection.end();
+            return parsedMails;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to get unread mail:', err.message);
+            if (connection)
+                connection.end();
+            return [];
+        }
+    }
+    /**
+     * 최근 메일 가져오기 (읽음/안읽음 모두)
+     */
+    async getRecentMail(limit = 10) {
+        let connection;
+        try {
+            connection = await this.getImapConnection();
+            const box = await connection.openBox('INBOX');
+            // 메일함의 전체 메시지 수
+            const totalMessages = box.messages.total;
+            if (totalMessages === 0) {
+                connection.end();
+                return [];
+            }
+            // 최근 N개의 UID 범위 계산
+            const startSeq = Math.max(1, totalMessages - limit + 1);
+            const endSeq = totalMessages;
+            const searchCriteria = [[`${startSeq}:${endSeq}`]];
+            const fetchOptions = {
+                bodies: ['HEADER', 'TEXT', ''],
+                struct: true,
+                markSeen: false
+            };
+            const messages = await connection.search(searchCriteria, fetchOptions);
+            // 최신 메일부터 정렬
+            const recentMessages = messages.reverse();
+            const parsedMails = [];
+            for (const item of recentMessages) {
+                const mail = await this.parseImapMessage(item);
+                if (mail)
+                    parsedMails.push(mail);
+            }
+            connection.end();
+            return parsedMails;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to get recent mail:', err.message);
+            if (connection)
+                connection.end();
+            return [];
+        }
+    }
+    /**
+     * 메일 ID로 조회
+     */
+    async getMailById(mailId) {
+        let connection;
+        try {
+            connection = await this.getImapConnection();
+            await connection.openBox('INBOX');
+            const uid = parseInt(mailId);
+            const fetchOptions = {
+                bodies: ['HEADER', 'TEXT', ''],
+                struct: true
+            };
+            const messages = await connection.search([['UID', uid]], fetchOptions);
+            if (messages.length === 0) {
+                connection.end();
+                return null;
+            }
+            const mail = await this.parseImapMessage(messages[0]);
+            connection.end();
+            return mail;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to get mail by ID:', err.message);
+            if (connection)
+                connection.end();
+            return null;
+        }
+    }
+    /**
+     * 메일 발송
+     */
+    async sendMail(params) {
+        try {
+            const recipients = Array.isArray(params.to) ? params.to : [params.to];
+            const mailOptions = {
+                from: this.config.email,
+                to: recipients.join(', '),
+                subject: params.subject,
+                text: params.html ? undefined : params.body,
+                html: params.html ? params.body : undefined,
+                cc: params.cc?.join(', '),
+                bcc: params.bcc?.join(', '),
+                attachments: params.attachments
+            };
+            const info = await this.smtpTransporter.sendMail(mailOptions);
+            console.log('[Dooray] Mail sent:', info.messageId);
+            return {
+                success: true,
+                mailId: info.messageId
+            };
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to send mail:', err.message);
+            return { success: false };
+        }
+    }
+    /**
+     * 메일 읽음 처리
+     */
+    async markAsRead(mailId) {
+        let connection;
+        try {
+            connection = await this.getImapConnection();
+            await connection.openBox('INBOX');
+            const uid = parseInt(mailId);
+            await connection.addFlags(uid, '\\Seen');
+            connection.end();
+            return true;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to mark as read:', err.message);
+            if (connection)
+                connection.end();
+            return false;
+        }
+    }
+    /**
+     * 메일 검색
+     */
+    async searchMail(query, limit = 10) {
+        let connection;
+        try {
+            connection = await this.getImapConnection();
+            await connection.openBox('INBOX');
+            // IMAP SEARCH: 제목이나 본문에서 검색
+            const searchCriteria = [
+                'OR',
+                ['SUBJECT', query],
+                ['BODY', query]
+            ];
+            const fetchOptions = {
+                bodies: ['HEADER', 'TEXT', ''],
+                struct: true
+            };
+            const messages = await connection.search(searchCriteria, fetchOptions);
+            // 최신 메일부터 limit개만
+            const limitedMessages = messages.slice(0, limit);
+            const parsedMails = [];
+            for (const item of limitedMessages) {
+                const mail = await this.parseImapMessage(item);
+                if (mail)
+                    parsedMails.push(mail);
+            }
+            connection.end();
+            return parsedMails;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to search mail:', err.message);
+            if (connection)
+                connection.end();
+            return [];
+        }
+    }
+    /**
+     * IMAP 메시지 파싱
+     */
+    async parseImapMessage(item) {
+        try {
+            const all = item.parts.find((part) => part.which === '');
+            const uid = item.attributes.uid;
+            const flags = item.attributes.flags || [];
+            if (!all || !all.body) {
+                return null;
+            }
+            const parsed = await (0, mailparser_1.simpleParser)(all.body);
+            return {
+                id: uid.toString(),
+                subject: parsed.subject || '(제목 없음)',
+                from: {
+                    name: parsed.from?.value[0]?.name || parsed.from?.text || '알 수 없음',
+                    email: parsed.from?.value[0]?.address || ''
+                },
+                to: (parsed.to?.value || []).map((addr) => ({
+                    name: addr.name || addr.address,
+                    email: addr.address
+                })),
+                body: parsed.text || '',
+                bodyHtml: parsed.html || undefined,
+                receivedAt: parsed.date?.toISOString() || new Date().toISOString(),
+                isRead: flags.includes('\\Seen'),
+                hasAttachments: (parsed.attachments?.length || 0) > 0
+            };
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Failed to parse message:', err.message);
+            return null;
+        }
+    }
+    /**
+     * 연결 테스트
+     */
+    async testConnection() {
+        try {
+            // SMTP 테스트
+            await this.smtpTransporter.verify();
+            console.log('[Dooray] SMTP connection verified');
+            // IMAP 테스트
+            const connection = await this.getImapConnection();
+            await connection.openBox('INBOX');
+            connection.end();
+            console.log('[Dooray] IMAP connection verified');
+            return true;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray] Connection test failed:', err.message);
+            return false;
+        }
+    }
+    /**
+     * 리소스 정리
+     */
+    async close() {
+        if (this.imapConnection) {
+            try {
+                this.imapConnection.end();
+            }
+            catch (error) {
+                // Ignore
+            }
+        }
+    }
+}
+exports.DoorayMailClient = DoorayMailClient;
+//# sourceMappingURL=mail-client.js.map

package/dist/security.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Security Manager
+ *
+ * 비밀번호 및 민감정보 암호화/복호화
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityManager = void 0;
+const crypto = __importStar(require("crypto"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
+class SecurityManager {
+    constructor(encryptionKey) {
+        // 사용자 제공 키 또는 머신별 자동 생성
+        this.encryptionKey = encryptionKey || this.generateMachineKey();
+    }
+    /**
+     * 머신별 고유 암호화 키 생성
+     */
+    generateMachineKey() {
+        const machineId = require('os').hostname() + require('os').platform();
+        return crypto.createHash('sha256').update(machineId).digest('hex');
+    }
+    /**
+     * 비밀번호/토큰 암호화
+     */
+    async encryptToken(token) {
+        try {
+            const encrypted = crypto_js_1.default.AES.encrypt(token, this.encryptionKey).toString();
+            return encrypted;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray Security] Encryption failed:', err.message);
+            throw new Error('Failed to encrypt token');
+        }
+    }
+    /**
+     * 비밀번호/토큰 복호화
+     */
+    async decryptToken(encryptedToken) {
+        try {
+            // 타입 체크
+            if (typeof encryptedToken !== 'string') {
+                console.warn('[Dooray Security] Token is not a string, returning as-is');
+                return String(encryptedToken);
+            }
+            
+            // CryptoJS 암호화 형식 확인
+            if (!encryptedToken.includes('U2FsdGVkX1')) {
+                // 평문으로 보임
+                console.warn('[Dooray Security] Token appears unencrypted');
+                return encryptedToken;
+            }
+            
+            const decrypted = crypto_js_1.default.AES.decrypt(encryptedToken, this.encryptionKey);
+            const token = decrypted.toString(crypto_js_1.default.enc.Utf8);
+            
+            if (!token) {
+                throw new Error('Decryption resulted in empty token');
+            }
+            
+            return token;
+        }
+        catch (error) {
+            const err = error;
+            console.error('[Dooray Security] Decryption failed:', err.message);
+            // 복호화 실패 시 원본 반환 (평문일 가능성)
+            return String(encryptedToken);
+        }
+    }
+    /**
+     * 이메일 주소 검증
+     */
+    validateEmail(email) {
+        const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailPattern.test(email);
+    }
+    /**
+     * 민감정보 로그 정제
+     */
+    sanitizeForLog(data) {
+        const sensitive = ['password', 'token', 'apiToken', 'authorization', 'pass'];
+        const sanitized = { ...data };
+        for (const key of sensitive) {
+            if (sanitized[key]) {
+                sanitized[key] = '***REDACTED***';
+            }
+        }
+        return sanitized;
+    }
+    /**
+     * 비밀번호 강도 확인
+     */
+    checkPasswordStrength(password) {
+        const feedback = [];
+        let score = 0;
+        if (password.length >= 8)
+            score++;
+        else
+            feedback.push('비밀번호는 최소 8자 이상이어야 합니다');
+        if (password.length >= 12)
+            score++;
+        if (/[a-z]/.test(password))
+            score++;
+        else
+            feedback.push('소문자를 포함해야 합니다');
+        if (/[A-Z]/.test(password))
+            score++;
+        else
+            feedback.push('대문자를 포함해야 합니다');
+        if (/[0-9]/.test(password))
+            score++;
+        else
+            feedback.push('숫자를 포함해야 합니다');
+        if (/[^a-zA-Z0-9]/.test(password))
+            score++;
+        else
+            feedback.push('특수문자를 포함해야 합니다');
+        return {
+            strong: score >= 4,
+            score,
+            feedback
+        };
+    }
+}
+exports.SecurityManager = SecurityManager;
+//# sourceMappingURL=security.js.map

package/dooray-cli.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+
+/**
+ * Dooray IMAP/SMTP CLI
+ * Command-line interface for Dooray mail operations
+ */
+
+const { DoorayMailClient } = require('./dist/mail-client');
+const { SecurityManager } = require('./dist/security');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_PATH = path.join(os.homedir(), '.dooray-config.json');
+
+// CLI 명령어 파서
+const args = process.argv.slice(2);
+const command = args[0];
+
+// 설정 로드
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    console.error('❌ Configuration not found. Run: dooray-cli config');
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+}
+
+// 설정 저장
+function saveConfig(config) {
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+// 메일 클라이언트 생성
+async function createClient(config) {
+  const security = new SecurityManager();
+  const decryptedPassword = await security.decryptToken(config.password);
+  
+  return new DoorayMailClient({
+    email: config.email,
+    password: decryptedPassword,
+    imap: config.imap || { host: 'imap.dooray.com', port: 993, secure: true },
+    smtp: config.smtp || { host: 'smtp.dooray.com', port: 465, secure: true }
+  });
+}
+
+// 명령어 핸들러
+async function handleCommand() {
+  switch (command) {
+    case 'config':
+      await configCommand();
+      break;
+    case 'list':
+      await listCommand();
+      break;
+    case 'recent':
+      await recentCommand();
+      break;
+    case 'read':
+      await readCommand(args[1]);
+      break;
+    case 'send':
+      await sendCommand(args.slice(1));
+      break;
+    case 'search':
+      await searchCommand(args.slice(1));
+      break;
+    case 'unread':
+      await unreadCountCommand();
+      break;
+    case 'test':
+      await testCommand();
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+      showHelp();
+      break;
+    default:
+      console.error(`❌ Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+// config: 설정 저장
+async function configCommand() {
+  const readline = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const question = (q) => new Promise(resolve => readline.question(q, resolve));
+
+  try {
+    console.log('\n📧 Dooray Configuration Setup\n');
+    
+    const email = await question('Email: ');
+    const password = await question('Password: ');
+    
+    const security = new SecurityManager();
+    const encryptedPassword = await security.encryptToken(password);
+    
+    const config = {
+      email,
+      password: encryptedPassword,
+      imap: { host: 'imap.dooray.com', port: 993, secure: true },
+      smtp: { host: 'smtp.dooray.com', port: 465, secure: true }
+    };
+    
+    saveConfig(config);
+    console.log(`\n✅ Configuration saved to ${CONFIG_PATH}`);
+  } finally {
+    readline.close();
+  }
+}
+
+// list: 읽지 않은 메일 목록
+async function listCommand() {
+  const config = loadConfig();
+  const client = await createClient(config);
+  
+  try {
+    const mails = await client.getUnreadMail(10);
+    
+    if (mails.length === 0) {
+      console.log('📭 No unread mails');
+      return;
+    }
+    
+    console.log(`\n📬 Unread Mails (${mails.length})\n`);
+    mails.forEach((mail, idx) => {
+      const fromText = typeof mail.from === 'object' ? `${mail.from.name} <${mail.from.email}>` : mail.from;
+      console.log(`${idx + 1}. [UID: ${mail.id}] ${fromText}`);
+      console.log(`   Subject: ${mail.subject}`);
+      console.log(`   Date: ${mail.receivedAt}\n`);
+    });
+  } finally {
+    await client.close();
+  }
+}
+
+// recent: 최근 메일 목록 (읽음/안읽음 모두)
+async function recentCommand() {
+  const config = loadConfig();
+  const client = await createClient(config);
+  
+  try {
+    const mails = await client.getRecentMail(10);
+    
+    if (mails.length === 0) {
+      console.log('📭 No mails found');
+      return;
+    }
+    
+    console.log(`\n📬 Recent Mails (${mails.length})\n`);
+    mails.forEach((mail, idx) => {
+      const readStatus = mail.isRead ? '✓' : '●';
+      const fromText = typeof mail.from === 'object' ? `${mail.from.name} <${mail.from.email}>` : mail.from;
+      console.log(`${idx + 1}. ${readStatus} [UID: ${mail.id}] ${fromText}`);
+      console.log(`   Subject: ${mail.subject}`);
+      console.log(`   Date: ${mail.receivedAt}\n`);
+    });
+  } finally {
+    await client.close();
+  }
+}
+
+// read: 특정 메일 읽기
+async function readCommand(uid) {
+  if (!uid) {
+    console.error('❌ Usage: dooray-cli read <uid>');
+    process.exit(1);
+  }
+  
+  const config = loadConfig();
+  const client = await createClient(config);
+  
+  try {
+    const mail = await client.getMailById(uid);
+    
+    if (!mail) {
+      console.error('❌ Mail not found');
+      process.exit(1);
+    }
+    
+    const fromText = typeof mail.from === 'object' ? `${mail.from.name} <${mail.from.email}>` : mail.from;
+    const toText = Array.isArray(mail.to) 
+      ? mail.to.map(t => typeof t === 'object' ? `${t.name} <${t.email}>` : t).join(', ')
+      : mail.to;
+    
+    console.log('\n📧 Mail Details\n');
+    console.log(`From: ${fromText}`);
+    console.log(`To: ${toText}`);
+    console.log(`Subject: ${mail.subject}`);
+    console.log(`Date: ${mail.receivedAt}`);
+    console.log(`Read: ${mail.isRead ? 'Yes' : 'No'}`);
+    console.log(`Attachments: ${mail.hasAttachments ? 'Yes' : 'No'}\n`);
+    console.log('─'.repeat(50));
+    console.log(mail.body || mail.bodyHtml || '(No content)');
+    console.log('─'.repeat(50));
+  } finally {
+    await client.close();
+  }
+}
+
+// send: 메일 발송
+async function sendCommand(args) {
+  // 비인터랙티브 모드: --to, --subject, --body 옵션 사용
+  let to, subject, body;
+  
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--to' && args[i + 1]) {
+      to = args[++i];
+    } else if (args[i] === '--subject' && args[i + 1]) {
+      subject = args[++i];
+    } else if (args[i] === '--body' && args[i + 1]) {
+      body = args[++i];
+    }
+  }
+
+  // 비인터랙티브 모드로 전달된 경우
+  if (to && subject && body) {
+    const config = loadConfig();
+    const client = await createClient(config);
+    
+    try {
+      await client.sendMail({ to, subject, text: body });
+      console.log('✅ Mail sent successfully');
+      console.log(`   To: ${to}`);
+      console.log(`   Subject: ${subject}`);
+      return;
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+      process.exit(1);
+    } finally {
+      await client.close();
+    }
+  }
+
+  // 인터랙티브 모드
+  const readline = require('readline').createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const question = (q) => new Promise(resolve => readline.question(q, resolve));
+
+  try {
+    to = to || await question('To: ');
+    subject = subject || await question('Subject: ');
+    
+    if (!body) {
+      console.log('Body (type message, press Ctrl+D when done):');
+      
+      body = '';
+      readline.on('line', (line) => {
+        body += line + '\n';
+      });
+      
+      await new Promise(resolve => readline.on('close', resolve));
+    }
+    
+    const config = loadConfig();
+    const client = await createClient(config);
+    
+    try {
+      await client.sendMail({ to, subject, text: body.trim() });
+      console.log('\n✅ Mail sent successfully');
+    } finally {
+      await client.close();
+    }
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+// search: 메일 검색
+async function searchCommand(keywords) {
+  if (keywords.length === 0) {
+    console.error('❌ Usage: dooray-cli search <keyword1> [keyword2] ...');
+    process.exit(1);
+  }
+  
+  const config = loadConfig();
+  const client = await createClient(config);
+  
+  try {
+    const criteria = keywords.map(k => ['SUBJECT', k]);
+    const mails = await client.searchMail(criteria);
+    
+    if (mails.length === 0) {
+      console.log('📭 No matching mails found');
+      return;
+    }
+    
+    console.log(`\n🔍 Search Results (${mails.length})\n`);
+    mails.slice(0, 10).forEach((mail, idx) => {
+      console.log(`${idx + 1}. [UID: ${mail.uid}] ${mail.from}`);
+      console.log(`   Subject: ${mail.subject}`);
+      console.log(`   Date: ${mail.date}\n`);
+    });
+  } finally {
+    await client.close();
+  }
+}
+
+// unread: 읽지 않은 메일 개수
+async function unreadCountCommand() {
+  const config = loadConfig();
+  const client = await createClient(config);
+  
+  try {
+    const count = await client.getUnreadCount();
+    console.log(`📬 Unread mails: ${count}`);
+  } finally {
+    await client.close();
+  }
+}
+
+// test: 연결 테스트
+async function testCommand() {
+  const config = loadConfig();
+  const client = await createClient(config);
+  
+  try {
+    const result = await client.testConnection();
+    
+    if (result) {
+      console.log('\n🎉 All connections successful!');
+    } else {
+      console.error('❌ Connection test failed');
+      process.exit(1);
+    }
+  } finally {
+    await client.close();
+  }
+}
+
+// help: 도움말
+function showHelp() {
+  console.log(`
+📧 Dooray CLI - IMAP/SMTP mail client for Dooray
+
+Usage: dooray-cli <command> [options]
+
+Commands:
+  config              Set up email configuration
+  list                List unread mails only
+  recent              List recent mails (read + unread)
+  read <uid>          Read a specific mail by UID
+  send                Send a new mail (interactive)
+  send --to <email> --subject <subject> --body <body>
+                      Send a mail (non-interactive)
+  search <keywords>   Search mails by keywords
+  unread              Show unread mail count
+  test                Test IMAP/SMTP connection
+  help                Show this help message
+
+Examples:
+  dooray-cli config
+  dooray-cli list
+  dooray-cli recent
+  dooray-cli read 123
+  dooray-cli send --to "user@example.com" --subject "Hello" --body "Test message"
+  dooray-cli search "meeting" "report"
+  dooray-cli unread
+
+Configuration file: ${CONFIG_PATH}
+`);
+}
+
+// 메인 실행
+handleCommand().catch(error => {
+  console.error('❌ Error:', error.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "dooray-mail-cli",
+  "version": "0.1.0",
+  "description": "Dooray mail CLI for OpenClaw Skill - IMAP/SMTP integration",
+  "main": "./dist/mail-client.js",
+  "bin": {
+    "dooray-cli": "dooray-cli.js"
+  },
+  "files": [
+    "dist/",
+    "dooray-cli.js",
+    "SKILL.md",
+    "README.md"
+  ],
+  "keywords": [
+    "openclaw",
+    "dooray",
+    "mail",
+    "cli",
+    "skill",
+    "imap",
+    "smtp"
+  ],
+  "author": "Anonymous",
+  "license": "MIT",
+  "dependencies": {
+    "crypto-js": "^4.2.0",
+    "imap-simple": "^5.1.0",
+    "mailparser": "^3.6.0",
+    "nodemailer": "^6.9.0"
+  }
+}