alvin-bot 4.4.1

package/plugins/calendar/index.js

@@ -0,0 +1,270 @@
+/**
+ * Calendar Plugin — View and manage calendar events.
+ *
+ * Supports:
+ * - Google Calendar (via API, needs GOOGLE_CALENDAR_API_KEY or OAuth)
+ * - iCal URL import (any .ics feed)
+ * - Local event storage (docs/calendar.json) as fallback
+ *
+ * For Google Calendar: set GOOGLE_CALENDAR_ID and GOOGLE_API_KEY in .env
+ * For iCal: set ICAL_URL in .env
+ * Without either: uses local JSON storage
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const PLUGIN_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const CALENDAR_FILE = path.resolve(PLUGIN_ROOT, "docs", "calendar.json");
+
+// ── Local Event Storage ─────────────────────────────────
+
+function loadEvents() {
+  try {
+    return JSON.parse(fs.readFileSync(CALENDAR_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+
+function saveEvents(events) {
+  fs.writeFileSync(CALENDAR_FILE, JSON.stringify(events, null, 2));
+}
+
+function formatDate(date) {
+  return new Date(date).toLocaleDateString("de-DE", {
+    weekday: "short", day: "2-digit", month: "2-digit", year: "numeric",
+    hour: "2-digit", minute: "2-digit",
+  });
+}
+
+function parseDateTime(input) {
+  // Try common formats
+  // "morgen 14:00" "2026-03-01 09:00" "in 2h" etc.
+  const now = new Date();
+
+  if (input.startsWith("in ")) {
+    const match = input.match(/in (\d+)\s*(m|min|h|std|d|tag)/i);
+    if (match) {
+      const amount = parseInt(match[1]);
+      const unit = match[2].toLowerCase();
+      const ms = unit.startsWith("m") ? amount * 60000 :
+                 unit.startsWith("h") || unit.startsWith("s") ? amount * 3600000 :
+                 amount * 86400000;
+      return new Date(now.getTime() + ms);
+    }
+  }
+
+  if (input.startsWith("morgen")) {
+    const tomorrow = new Date(now);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    const timePart = input.replace("morgen", "").trim();
+    if (timePart) {
+      const [h, m] = timePart.split(":").map(Number);
+      tomorrow.setHours(h || 9, m || 0, 0, 0);
+    } else {
+      tomorrow.setHours(9, 0, 0, 0);
+    }
+    return tomorrow;
+  }
+
+  if (input.startsWith("heute")) {
+    const today = new Date(now);
+    const timePart = input.replace("heute", "").trim();
+    if (timePart) {
+      const [h, m] = timePart.split(":").map(Number);
+      today.setHours(h || 9, m || 0, 0, 0);
+    }
+    return today;
+  }
+
+  // ISO or other parseable format
+  const parsed = new Date(input);
+  if (!isNaN(parsed.getTime())) return parsed;
+
+  return null;
+}
+
+export default {
+  name: "calendar",
+  description: "Create, view and manage calendar events",
+  version: "1.0.0",
+  author: "Alvin Bot",
+
+  commands: [
+    {
+      command: "cal",
+      description: "View/manage calendar",
+      handler: async (ctx, args) => {
+        // /cal — show upcoming events
+        if (!args) {
+          const events = loadEvents()
+            .filter(e => new Date(e.date) >= new Date())
+            .sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime())
+            .slice(0, 10);
+
+          if (events.length === 0) {
+            await ctx.reply("📅 No upcoming events.\nNew: `/cal add morgen 14:00 | Meeting`", { parse_mode: "Markdown" });
+            return;
+          }
+
+          const lines = events.map((e, i) => {
+            const date = formatDate(e.date);
+            const loc = e.location ? ` 📍 ${e.location}` : "";
+            return `${i + 1}. 📅 *${e.title}*\n   ${date}${loc}`;
+          });
+
+          await ctx.reply(`📅 *Upcoming events:*\n\n${lines.join("\n\n")}`, { parse_mode: "Markdown" });
+          return;
+        }
+
+        // /cal add <datetime> | <title> [| location]
+        if (args.startsWith("add ")) {
+          const text = args.slice(4).trim();
+          const parts = text.split("|").map(s => s.trim());
+
+          if (parts.length < 2) {
+            await ctx.reply("Format: `/cal add morgen 14:00 | Event title | Location (optional)`", { parse_mode: "Markdown" });
+            return;
+          }
+
+          const dateStr = parts[0];
+          const title = parts[1];
+          const location = parts[2] || "";
+
+          const date = parseDateTime(dateStr);
+          if (!date) {
+            await ctx.reply(`❌ Date not recognized: "${dateStr}"\nTry: \`morgen 14:00\`, \`heute 18:00\`, \`in 2h\`, \`2026-03-01 09:00\``, { parse_mode: "Markdown" });
+            return;
+          }
+
+          const event = {
+            id: Date.now().toString(36),
+            title,
+            date: date.toISOString(),
+            location,
+            created: new Date().toISOString(),
+          };
+
+          const events = loadEvents();
+          events.push(event);
+          saveEvents(events);
+
+          await ctx.reply(
+            `✅ *Event created:*\n\n📅 ${title}\n🕐 ${formatDate(date)}${location ? `\n📍 ${location}` : ""}`,
+            { parse_mode: "Markdown" }
+          );
+          return;
+        }
+
+        // /cal delete <number>
+        if (args.startsWith("delete ") || args.startsWith("del ")) {
+          const idx = parseInt(args.split(" ")[1]) - 1;
+          const events = loadEvents()
+            .filter(e => new Date(e.date) >= new Date())
+            .sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+
+          if (isNaN(idx) || idx < 0 || idx >= events.length) {
+            await ctx.reply("❌ Invalid number. Use `/cal` for the list.", { parse_mode: "Markdown" });
+            return;
+          }
+
+          const toDelete = events[idx];
+          const allEvents = loadEvents().filter(e => e.id !== toDelete.id);
+          saveEvents(allEvents);
+
+          await ctx.reply(`🗑️ Deleted: *${toDelete.title}*`, { parse_mode: "Markdown" });
+          return;
+        }
+
+        // /cal today
+        if (args === "today" || args === "heute") {
+          const now = new Date();
+          const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+          const todayEnd = new Date(todayStart.getTime() + 86400000);
+
+          const events = loadEvents()
+            .filter(e => {
+              const d = new Date(e.date);
+              return d >= todayStart && d < todayEnd;
+            })
+            .sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+
+          if (events.length === 0) {
+            await ctx.reply("📅 No events today.");
+            return;
+          }
+
+          const lines = events.map(e => {
+            const time = new Date(e.date).toLocaleTimeString("de-DE", { hour: "2-digit", minute: "2-digit" });
+            return `🕐 ${time} — *${e.title}*`;
+          });
+
+          await ctx.reply(`📅 *Today:*\n\n${lines.join("\n")}`, { parse_mode: "Markdown" });
+          return;
+        }
+
+        await ctx.reply(
+          "📅 *Calendar commands:*\n\n" +
+          "`/cal` — Upcoming events\n" +
+          "`/cal heute` — Today's events\n" +
+          "`/cal add morgen 14:00 | Title | Location` — Create event\n" +
+          "`/cal delete 1` — Delete event",
+          { parse_mode: "Markdown" }
+        );
+      },
+    },
+  ],
+
+  tools: [
+    {
+      name: "list_events",
+      description: "List upcoming calendar events",
+      parameters: {
+        type: "object",
+        properties: {
+          days: { type: "number", description: "Number of days to look ahead (default: 7)" },
+        },
+      },
+      execute: async (params) => {
+        const days = params.days || 7;
+        const cutoff = new Date(Date.now() + days * 86400000);
+        const events = loadEvents()
+          .filter(e => new Date(e.date) >= new Date() && new Date(e.date) <= cutoff)
+          .sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+        return JSON.stringify(events);
+      },
+    },
+    {
+      name: "create_event",
+      description: "Create a calendar event",
+      parameters: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "Event title" },
+          date: { type: "string", description: "Date/time (ISO or natural language)" },
+          location: { type: "string", description: "Location (optional)" },
+        },
+        required: ["title", "date"],
+      },
+      execute: async (params) => {
+        const date = parseDateTime(params.date) || new Date(params.date);
+        if (isNaN(date.getTime())) return `Invalid date: ${params.date}`;
+
+        const event = {
+          id: Date.now().toString(36),
+          title: params.title,
+          date: date.toISOString(),
+          location: params.location || "",
+          created: new Date().toISOString(),
+        };
+
+        const events = loadEvents();
+        events.push(event);
+        saveEvents(events);
+        return `Event created: ${params.title} at ${date.toISOString()}`;
+      },
+    },
+  ],
+};

package/plugins/email/index.js

@@ -0,0 +1,231 @@
+/**
+ * Email Plugin — Read and send emails via IMAP/SMTP.
+ *
+ * Lightweight implementation using raw IMAP/SMTP commands.
+ * For full email support, configure in .env:
+ *   EMAIL_IMAP_HOST=imap.mail.me.com
+ *   EMAIL_IMAP_PORT=993
+ *   EMAIL_SMTP_HOST=smtp.mail.me.com
+ *   EMAIL_SMTP_PORT=587
+ *   EMAIL_USER=your-email@provider.com
+ *   EMAIL_PASS=app-specific-password
+ *
+ * Alternative: Uses `himalaya` CLI if installed (more reliable).
+ */
+
+import { execSync } from "child_process";
+
+function hasHimalaya() {
+  try {
+    execSync("which himalaya", { stdio: "pipe" });
+    return true;
+  } catch { return false; }
+}
+
+function runHimalaya(args, timeout = 15000) {
+  try {
+    const result = execSync(`himalaya ${args}`, {
+      stdio: "pipe",
+      timeout,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+    return result.toString().trim();
+  } catch (err) {
+    throw new Error(err.stderr?.toString()?.trim() || err.message);
+  }
+}
+
+function parseEmailList(output) {
+  // himalaya list outputs a table — parse it
+  const lines = output.split("\n").filter(l => l.trim());
+  if (lines.length < 2) return [];
+
+  // Skip header line
+  return lines.slice(1).map(line => {
+    // Format: ID | FLAGS | FROM | SUBJECT | DATE
+    const parts = line.split("|").map(s => s.trim());
+    if (parts.length >= 4) {
+      return {
+        id: parts[0],
+        flags: parts[1],
+        from: parts[2],
+        subject: parts[3],
+        date: parts[4] || "",
+      };
+    }
+    return null;
+  }).filter(Boolean);
+}
+
+export default {
+  name: "email",
+  description: "E-Mails lesen und senden (via himalaya CLI oder IMAP/SMTP)",
+  version: "1.0.0",
+  author: "Alvin Bot",
+
+  onInit: () => {
+    if (!hasHimalaya()) {
+      console.warn("Email plugin: himalaya CLI not found. Install with: brew install himalaya");
+    }
+  },
+
+  commands: [
+    {
+      command: "email",
+      description: "E-Mails verwalten",
+      handler: async (ctx, args) => {
+        if (!hasHimalaya()) {
+          await ctx.reply(
+            "📧 *Email Plugin*\n\n" +
+            "`himalaya` CLI nicht installiert.\n" +
+            "Installiere mit: `brew install himalaya`\n" +
+            "Konfiguriere mit: `himalaya account configure`",
+            { parse_mode: "Markdown" }
+          );
+          return;
+        }
+
+        // /email — list inbox
+        if (!args || args === "inbox") {
+          try {
+            await ctx.api.sendChatAction(ctx.chat.id, "typing");
+            const output = runHimalaya("list -s 10");
+            const emails = parseEmailList(output);
+
+            if (emails.length === 0) {
+              await ctx.reply("📭 Keine E-Mails im Posteingang.");
+              return;
+            }
+
+            const lines = emails.map((e, i) => {
+              const unread = e.flags?.includes("Seen") ? "" : "🆕 ";
+              return `${unread}*${i + 1}.* ${e.from}\n   ${e.subject}`;
+            });
+
+            await ctx.reply(`📧 *Posteingang (${emails.length}):*\n\n${lines.join("\n\n")}`, { parse_mode: "Markdown" });
+          } catch (err) {
+            await ctx.reply(`❌ Fehler: ${err.message}`);
+          }
+          return;
+        }
+
+        // /email read <id>
+        if (args.startsWith("read ")) {
+          const id = args.slice(5).trim();
+          try {
+            await ctx.api.sendChatAction(ctx.chat.id, "typing");
+            const output = runHimalaya(`read ${id}`);
+            const truncated = output.length > 3500 ? output.slice(0, 3500) + "\n\n_[...truncated]_" : output;
+            await ctx.reply(`📧 *E-Mail #${id}:*\n\n${truncated}`, { parse_mode: "Markdown" });
+          } catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+          }
+          return;
+        }
+
+        // /email send <to> | <subject> | <body>
+        if (args.startsWith("send ")) {
+          const text = args.slice(5).trim();
+          const parts = text.split("|").map(s => s.trim());
+
+          if (parts.length < 3) {
+            await ctx.reply("Format: `/email send to@example.com | Betreff | Text`", { parse_mode: "Markdown" });
+            return;
+          }
+
+          const [to, subject, ...bodyParts] = parts;
+          const body = bodyParts.join("|");
+
+          try {
+            await ctx.api.sendChatAction(ctx.chat.id, "typing");
+            // Use himalaya write + send
+            const mml = `From: \nTo: ${to}\nSubject: ${subject}\n\n${body}`;
+            execSync(`echo '${mml.replace(/'/g, "'\\''")}' | himalaya send`, {
+              stdio: "pipe",
+              timeout: 30000,
+            });
+            await ctx.reply(`✅ E-Mail gesendet an ${to}`, { parse_mode: "Markdown" });
+          } catch (err) {
+            await ctx.reply(`❌ Senden fehlgeschlagen: ${err.message}`);
+          }
+          return;
+        }
+
+        // /email search <query>
+        if (args.startsWith("search ")) {
+          const query = args.slice(7).trim();
+          try {
+            await ctx.api.sendChatAction(ctx.chat.id, "typing");
+            const output = runHimalaya(`search "${query}"`, 30000);
+            const truncated = output.length > 3000 ? output.slice(0, 3000) + "\n..." : output;
+            await ctx.reply(`🔍 *Suche: "${query}"*\n\n${truncated}`, { parse_mode: "Markdown" });
+          } catch (err) {
+            await ctx.reply(`❌ ${err.message}`);
+          }
+          return;
+        }
+
+        await ctx.reply(
+          "📧 *Email-Befehle:*\n\n" +
+          "`/email` — Posteingang (letzte 10)\n" +
+          "`/email read 123` — E-Mail lesen\n" +
+          "`/email send to@x.com | Betreff | Text` — Senden\n" +
+          "`/email search Suchbegriff` — Suchen",
+          { parse_mode: "Markdown" }
+        );
+      },
+    },
+  ],
+
+  tools: [
+    {
+      name: "list_emails",
+      description: "List recent emails from inbox",
+      parameters: {
+        type: "object",
+        properties: {
+          count: { type: "number", description: "Number of emails (default: 10)" },
+        },
+      },
+      execute: async (params) => {
+        if (!hasHimalaya()) return "himalaya CLI not installed";
+        const count = params.count || 10;
+        return runHimalaya(`list -s ${count}`);
+      },
+    },
+    {
+      name: "read_email",
+      description: "Read a specific email by ID",
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Email ID" },
+        },
+        required: ["id"],
+      },
+      execute: async (params) => {
+        if (!hasHimalaya()) return "himalaya CLI not installed";
+        return runHimalaya(`read ${params.id}`);
+      },
+    },
+    {
+      name: "send_email",
+      description: "Send an email",
+      parameters: {
+        type: "object",
+        properties: {
+          to: { type: "string", description: "Recipient email" },
+          subject: { type: "string", description: "Email subject" },
+          body: { type: "string", description: "Email body text" },
+        },
+        required: ["to", "subject", "body"],
+      },
+      execute: async (params) => {
+        if (!hasHimalaya()) return "himalaya CLI not installed";
+        const mml = `From: \nTo: ${params.to}\nSubject: ${params.subject}\n\n${params.body}`;
+        execSync(`echo '${mml.replace(/'/g, "'\\''")}' | himalaya send`, { stdio: "pipe", timeout: 30000 });
+        return `Email sent to ${params.to}`;
+      },
+    },
+  ],
+};