zubo 0.1.27 → 0.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zubo",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "Your AI agent that never forgets. Persistent memory, 25+ tools, 7 channels, 11+ LLM providers — runs entirely on your machine.",
   "license": "MIT",
   "author": "thomaskanze",

package/src/agent/prompts.ts

@@ -45,11 +45,16 @@ const DEFAULT_PERSONALITY = `You are Zubo, a personal AI agent. You are friendly
 - When the user says "remind me", "ping me", "follow up" — create a reminder.
 - Use follow_ups to schedule check-ins: "follow up about the dentist tomorrow", "check in about the project in 3 days".
 
-## Todos & notes
-
-- Use the todos tool when the user asks to track tasks, create to-do lists, or manage action items. "Add buy groceries to my list" → todos with action "add".
-- Use the notes tool to save, search, and organize information. "Save this recipe" → notes with action "save". "Find my notes about React" → notes with action "search".
-- When the user mentions something they need to do, proactively offer to add it as a todo.
+## Todos & notes
+
+- Use the todos tool when the user asks to track tasks, create to-do lists, or manage action items. "Add buy groceries to my list" → todos with action "add".
+- Use the notes tool to save, search, and organize information. "Save this recipe" → notes with action "save". "Find my notes about React" → notes with action "search".
+- When the user mentions something they need to do, proactively offer to add it as a todo.
+
+## Email actions
+
+- If the user asks you to send/write an email to someone, you must actually send it using a tool ("email_send" or "gmail"). Do not only draft text unless the user explicitly asks for a draft.
+- If required fields are missing, ask only for what's missing ("to", "subject", or "body") and send immediately once provided.
 
 ## Preferences
 

package/src/channels/email.ts

@@ -186,11 +186,27 @@ class ImapClient {
 
 // --- Minimal SMTP client ---
 
-class SmtpClient {
+class SmtpClient {
   private socket: Socket | tls.TLSSocket | null = null;
   private buffer = "";
 
-  constructor(private config: EmailConfig["smtp"], private fromName?: string) {}
+  constructor(private config: EmailConfig["smtp"], private fromName?: string) {}
+
+  private encodeMimeHeader(value: string): string {
+    const sanitized = value.replace(/[\r\n]+/g, " ").trim();
+    if (!sanitized) return "";
+    // RFC 2047 encoded-word for non-ASCII header values (emoji, accents, etc.).
+    if (/^[\x00-\x7F]*$/.test(sanitized)) return sanitized;
+    return `=?UTF-8?B?${Buffer.from(sanitized, "utf8").toString("base64")}?=`;
+  }
+
+  private toCrlfBody(body: string): string {
+    const normalized = body.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    return normalized
+      .split("\n")
+      .map((line) => (line.startsWith(".") ? `.${line}` : line))
+      .join("\r\n");
+  }
 
   private async connectRaw(): Promise<Socket | tls.TLSSocket> {
     return new Promise((resolve, reject) => {
@@ -237,7 +253,7 @@ class SmtpClient {
     });
   }
 
-  async sendEmail(to: string, subject: string, body: string, from?: string): Promise<void> {
+  async sendEmail(to: string, subject: string, body: string, from?: string): Promise<void> {
     const rawSocket = await this.connectRaw();
     let socket: Socket | tls.TLSSocket = rawSocket;
 
@@ -282,17 +298,21 @@ class SmtpClient {
       await this.sendCmd(socket, "DATA");
 
       // Message content — write directly to socket, not via sendCmd
-      const displayName = this.fromName || "Zubo";
-      const message = [
-        `From: ${displayName} <${fromAddr}>`,
-        `To: ${to}`,
-        `Subject: ${subject}`,
-        `Date: ${new Date().toUTCString()}`,
-        `Content-Type: text/plain; charset=utf-8`,
-        `Content-Transfer-Encoding: 8bit`,
-        ``,
-        body,
-      ].join("\r\n");
+      const displayName = this.fromName || "Zubo";
+      const encodedFromName = this.encodeMimeHeader(displayName);
+      const encodedSubject = this.encodeMimeHeader(subject);
+      const safeBody = this.toCrlfBody(body || "");
+      const message = [
+        `From: ${encodedFromName} <${fromAddr}>`,
+        `To: ${to}`,
+        `Subject: ${encodedSubject}`,
+        `Date: ${new Date().toUTCString()}`,
+        `MIME-Version: 1.0`,
+        `Content-Type: text/plain; charset=utf-8`,
+        `Content-Transfer-Encoding: 8bit`,
+        ``,
+        safeBody,
+      ].join("\r\n");
 
       // Send body then terminator, wait for 250 OK
       await new Promise<void>((resolve, reject) => {
@@ -312,7 +332,19 @@ class SmtpClient {
       socket.destroy();
     }
   }
-}
+}
+
+export async function sendSmtpEmail(
+  config: EmailConfig["smtp"],
+  to: string,
+  subject: string,
+  body: string,
+  fromName?: string,
+  from?: string,
+): Promise<void> {
+  const smtp = new SmtpClient(config, fromName);
+  await smtp.sendEmail(to, subject, body, from);
+}
 
 // --- Email channel adapter ---
 

package/src/start.ts

@@ -30,8 +30,9 @@ import { initMemory } from "./memory/engine";
 import { registerTodosTool } from "./tools/builtin/todos";
 import { registerNotesTool } from "./tools/builtin/notes";
 import { registerPreferencesTool } from "./tools/builtin/preferences";
-import { registerTopicsTool } from "./tools/builtin/topics";
-import { logger, enableFileLogging } from "./util/logger";
+import { registerTopicsTool } from "./tools/builtin/topics";
+import { registerEmailSendTool } from "./tools/builtin/email-send";
+import { logger, enableFileLogging } from "./util/logger";
 
 function openBrowser(url: string) {
   try {
@@ -234,12 +235,13 @@ export async function startZubo(isDaemon = false) {
   registerManageTriggersTool();
 
   // Register personal agent tools
-  registerTodosTool();
-  registerNotesTool();
-  registerPreferencesTool();
-  registerTopicsTool();
-  const { registerFollowUpsTool } = await import("./tools/builtin/follow-ups");
-  registerFollowUpsTool(db, router, config, llm);
+  registerTodosTool();
+  registerNotesTool();
+  registerPreferencesTool();
+  registerTopicsTool();
+  registerEmailSendTool();
+  const { registerFollowUpsTool } = await import("./tools/builtin/follow-ups");
+  registerFollowUpsTool(db, router, config, llm);
 
   // Register code interpreter tool
   if (config.codeInterpreter?.enabled !== false) {

package/src/tools/builtin/email-send.ts

@@ -0,0 +1,63 @@
+import { readFileSync } from "fs";
+import { registerTool } from "../registry";
+import { paths } from "../../config/paths";
+import { sendSmtpEmail, type EmailConfig } from "../../channels/email";
+
+function isValidEmail(value: string): boolean {
+  const trimmed = value.trim();
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed);
+}
+
+export function registerEmailSendTool(): void {
+  registerTool({
+    definition: {
+      name: "email_send",
+      description:
+        "Send an email using the configured SMTP account in channels.email.smtp. " +
+        "Use this when the user asks to send or write an email to someone.",
+      input_schema: {
+        type: "object",
+        properties: {
+          to: { type: "string", description: "Recipient email address" },
+          subject: { type: "string", description: "Email subject" },
+          body: { type: "string", description: "Email body content" },
+        },
+        required: ["to", "subject", "body"],
+      },
+    },
+    execute: async (input) => {
+      const to = String(input.to ?? "").trim();
+      const subject = String(input.subject ?? "").trim();
+      const body = String(input.body ?? "");
+
+      if (!to || !isValidEmail(to)) {
+        return "Invalid recipient email address. Please provide a valid `to` address.";
+      }
+      if (!subject) return "Subject is required.";
+      if (!body.trim()) return "Body is required.";
+
+      let parsed: any;
+      try {
+        parsed = JSON.parse(readFileSync(paths.config, "utf-8"));
+      } catch {
+        return "Could not read config. Run `zubo setup` and configure Email first.";
+      }
+
+      const emailCfg = parsed?.channels?.email as EmailConfig | undefined;
+      const smtpCfg = emailCfg?.smtp;
+      if (!smtpCfg?.host || !smtpCfg?.user || !smtpCfg?.password) {
+        return (
+          "Email is not configured yet. Configure `channels.email.smtp` in Settings > Channels > Email " +
+          "or run `zubo setup`."
+        );
+      }
+
+      try {
+        await sendSmtpEmail(smtpCfg, to, subject, body, emailCfg?.fromName);
+        return `Email sent to ${to} with subject "${subject}".`;
+      } catch (err: any) {
+        return `Failed to send email: ${err?.message ?? String(err)}`;
+      }
+    },
+  });
+}

package/src/tools/builtin-integrations/google/gmail/handler.ts

@@ -1,4 +1,11 @@
-const API = "https://gmail.googleapis.com/gmail/v1/users/me";
+const API = "https://gmail.googleapis.com/gmail/v1/users/me";
+
+function encodeMimeHeader(value: string): string {
+  const sanitized = String(value || "").replace(/[\r\n]+/g, " ").trim();
+  if (!sanitized) return "";
+  if (/^[\x00-\x7F]*$/.test(sanitized)) return sanitized;
+  return `=?UTF-8?B?${Buffer.from(sanitized, "utf8").toString("base64")}?=`;
+}
 
 async function getToken(): Promise<string> {
   // Try the new multi-provider OAuth system first
@@ -82,13 +89,15 @@ export default async function (input: Record<string, unknown>): Promise<string>
         }
         return JSON.stringify({ id: data.id, subject: getHeader("Subject"), from: getHeader("From"), date: getHeader("Date"), body: emailBody });
       }
-      case "send": {
-        if (!to) return JSON.stringify({ error: "to is required" });
-        if (!subject) return JSON.stringify({ error: "subject is required" });
-        const raw = Buffer.from(`MIME-Version: 1.0\r\nTo: ${to}\r\nSubject: ${subject}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body || ""}`).toString("base64url");
-        const res = await fetch(`${API}/messages/send`, {
-          method: "POST", headers,
-          body: JSON.stringify({ raw }),
+      case "send": {
+        if (!to) return JSON.stringify({ error: "to is required" });
+        if (!subject) return JSON.stringify({ error: "subject is required" });
+        const raw = Buffer.from(
+          `MIME-Version: 1.0\r\nTo: ${to}\r\nSubject: ${encodeMimeHeader(subject)}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body || ""}`
+        ).toString("base64url");
+        const res = await fetch(`${API}/messages/send`, {
+          method: "POST", headers,
+          body: JSON.stringify({ raw }),
         });
         if (!res.ok) return await safeApiErr(res, "Gmail");
         const data = (await res.json()) as any;
@@ -107,14 +116,16 @@ export default async function (input: Record<string, unknown>): Promise<string>
         const orig = await fetch(`${API}/messages/${message_id}?format=metadata&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=Message-ID`, { headers });
         if (!orig.ok) return await safeApiErr(orig, "Gmail");
         const origData = (await orig.json()) as any;
-        const getHeader = (name: string) => origData.payload?.headers?.find((h: any) => h.name === name)?.value ?? "";
-        const replyTo = getHeader("From");
-        const subj = getHeader("Subject").startsWith("Re:") ? getHeader("Subject") : `Re: ${getHeader("Subject")}`;
-        const msgId = getHeader("Message-ID");
-        const raw = Buffer.from(`MIME-Version: 1.0\r\nTo: ${replyTo}\r\nSubject: ${subj}\r\nIn-Reply-To: ${msgId}\r\nReferences: ${msgId}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body}`).toString("base64url");
-        const res = await fetch(`${API}/messages/send`, {
-          method: "POST", headers,
-          body: JSON.stringify({ raw, threadId: origData.threadId }),
+        const getHeader = (name: string) => origData.payload?.headers?.find((h: any) => h.name === name)?.value ?? "";
+        const replyTo = getHeader("From");
+        const subj = getHeader("Subject").startsWith("Re:") ? getHeader("Subject") : `Re: ${getHeader("Subject")}`;
+        const msgId = getHeader("Message-ID");
+        const raw = Buffer.from(
+          `MIME-Version: 1.0\r\nTo: ${replyTo}\r\nSubject: ${encodeMimeHeader(subj)}\r\nIn-Reply-To: ${msgId}\r\nReferences: ${msgId}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body}`
+        ).toString("base64url");
+        const res = await fetch(`${API}/messages/send`, {
+          method: "POST", headers,
+          body: JSON.stringify({ raw, threadId: origData.threadId }),
         });
         if (!res.ok) return await safeApiErr(res, "Gmail");
         const data = (await res.json()) as any;

package/src/tools/permissions.ts

@@ -53,8 +53,9 @@ const DEFAULT_PERMISSIONS: Record<string, ToolPermission> = {
   todos: "auto",
   notes: "auto",
   preferences: "auto",
-  topics: "auto",
-  follow_ups: "auto",
+  topics: "auto",
+  follow_ups: "auto",
+  email_send: "confirm",
 
   // Built-in skills — safe (read-only or low risk)
   web_search: "auto",
@@ -145,6 +146,7 @@ const TOOL_SCOPES: Record<string, ToolScope[]> = {
   preferences: ["memory"],
   topics: ["memory"],
   follow_ups: ["memory"],
+  email_send: ["network_write"],
   web_search: ["network_read"],
   url_fetch: ["network_read"],
   file_read: ["filesystem_read"],