@stacksjs/buddy 0.70.88 → 0.70.90

package/dist/commands/email.js

@@ -0,0 +1,524 @@
+import { readFileSync, existsSync } from "node:fs";
+import process from "node:process";
+import { email as emailConfig } from "@stacksjs/config";
+import { ExitCode } from "@stacksjs/types";
+import { onUnknownSubcommand } from "@stacksjs/cli";
+import { getErrorMessage } from "@stacksjs/utils";
+const TIMEOUT_MS = 30000;
+async function withTimeout(promise, ms = TIMEOUT_MS) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(Error(`Operation timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+let _awsCredsLoaded = !1;
+async function validateS3Bucket(bucket, region) {
+  try {
+    const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(region), list = s3.listObjects;
+    if (typeof list !== "function")
+      return { ok: !0 };
+    await withTimeout(list.call(s3, { bucket, maxKeys: 1 }), 5000);
+    return { ok: !0 };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/NoSuchBucket/i.test(message))
+      return {
+        ok: !1,
+        reason: `Bucket '${bucket}' does not exist in region '${region}'.`,
+        hint: "Run `buddy deploy` to create email infrastructure, or pass --bucket <name> if you know the correct bucket."
+      };
+    if (/AccessDenied|Forbidden/i.test(message))
+      return {
+        ok: !1,
+        reason: `Access denied to bucket '${bucket}'.`,
+        hint: "Check that AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY (or your IAM role) have s3:ListBucket permission for this bucket."
+      };
+    if (/region/i.test(message) || /PermanentRedirect/i.test(message))
+      return {
+        ok: !1,
+        reason: `Bucket '${bucket}' is not in region '${region}'.`,
+        hint: "Set AWS_REGION to the bucket's actual region, or pass the right bucket for this region."
+      };
+    return {
+      ok: !1,
+      reason: message,
+      hint: "Check AWS connectivity and credentials."
+    };
+  }
+}
+async function loadAwsCredentials() {
+  if (_awsCredsLoaded)
+    return;
+  _awsCredsLoaded = !0;
+  const envPath = ".env.production";
+  if (!existsSync(envPath))
+    return;
+  const { parse } = await import("@stacksjs/env"), content = readFileSync(envPath, "utf-8"), { parsed } = parse(content);
+  for (const [key, value] of Object.entries(parsed))
+    if (process.env[key] === void 0)
+      process.env[key] = value;
+}
+const descriptions = {
+  email: "Email server management commands",
+  verify: "Check domain verification status",
+  test: "Send a test email",
+  list: "List configured mailboxes",
+  logs: "View email processing logs",
+  status: "Show email server status",
+  inbox: "View inbox emails from S3",
+  reprocess: "Reprocess raw emails from S3 into mailbox structure"
+};
+export function email(buddy) {
+  buddy.command("email", descriptions.email).alias("mail").action(async () => {
+    console.log(`
+\uD83D\uDCE7 Email Server Commands
+`);
+    console.log("  buddy email:verify      - Check domain verification status");
+    console.log("  buddy email:test        - Send a test email");
+    console.log("  buddy email:list        - List configured mailboxes");
+    console.log("  buddy email:inbox       - View inbox emails from S3");
+    console.log("  buddy email:reprocess   - Reprocess raw emails into mailbox structure");
+    console.log("  buddy email:logs        - View email processing logs");
+    console.log("  buddy email:status      - Show email server status");
+    console.log("");
+  });
+  buddy.command("email:verify", descriptions.verify).action(async () => {
+    console.log(`
+\uD83D\uDCE7 Checking Email Domain Verification...
+`);
+    await loadAwsCredentials();
+    try {
+      const { SESClient } = await import("@stacksjs/ts-cloud"), ses = new SESClient(process.env.AWS_REGION || "us-east-1"), emailDomain = (emailConfig?.from?.address?.includes("@") ? emailConfig.from.address.split("@")[1] : void 0) || "stacksjs.com";
+      console.log(`Domain: ${emailDomain}`);
+      const identity = await withTimeout(ses.getEmailIdentity(emailDomain));
+      if (identity) {
+        console.log(`
+\u2705 Domain Status: ${identity.VerificationStatus || "Unknown"}`);
+        if (identity.DkimAttributes) {
+          console.log(`
+DKIM Status: ${identity.DkimAttributes.Status || "Unknown"}`);
+          if (identity.DkimAttributes.Tokens) {
+            console.log(`
+DKIM Records needed:`);
+            for (const token of identity.DkimAttributes.Tokens) {
+              console.log(`  CNAME: ${token}._domainkey.${emailDomain}`);
+              console.log(`  Value: ${token}.dkim.amazonses.com`);
+            }
+          }
+        }
+      } else
+        console.log("\n\u26A0\uFE0F  Domain not found in SES. Run `buddy deploy` to set up email.");
+    } catch (error) {
+      console.error(`
+\u274C Error checking verification:`, getErrorMessage(error));
+    }
+    process.exit(0);
+  });
+  buddy.command("email:test [recipient]", descriptions.test).action(async (recipient) => {
+    const to = recipient || emailConfig?.from?.address || "test@example.com", { config } = await import("@stacksjs/config"), driver = config?.email?.default || "ses";
+    console.log(`
+\uD83D\uDCE7 Sending Test Email to ${to} via the configured mailer ('${driver}')...
+`);
+    try {
+      const { mail } = await import("@stacksjs/email"), from = {
+        name: emailConfig?.from?.name || "Stacks",
+        address: emailConfig?.from?.address || `hello@${emailConfig?.domain || "stacksjs.com"}`
+      }, result = await mail.send({
+        to: [to],
+        from,
+        subject: "Test Email from Stacks",
+        text: "This is a test email sent from your Stacks application. If you received this, your mail setup is working.",
+        html: `<!doctype html><html><body style="font-family: sans-serif; padding: 20px;">
+            <h1>\uD83D\uDE80 Test Email from Stacks</h1>
+            <p>This is a test email sent from your Stacks application.</p>
+            <p>If you received this, your mail setup is working correctly!</p>
+            <hr><p style="color:#666;font-size:12px;">Sent from ${from.address} via the '${driver}' mailer.</p>
+          </body></html>`
+      });
+      if (result?.success === !1)
+        throw Error(result?.message || "send returned success=false");
+      console.log(`\u2705 Test email sent via '${driver}'!`);
+      if (result?.messageId)
+        console.log(`   Message ID: ${result.messageId}`);
+      if (driver === "log" || driver === "capture")
+        console.log(`
+\uD83D\uDCA1 The '${driver}' mailer does not deliver mail \u2014 set MAIL_MAILER=smtp (or ses) to send for real.`);
+    } catch (error) {
+      console.error(`
+\u274C Error sending test email via '${driver}':`, getErrorMessage(error));
+      if (driver === "smtp")
+        console.log(`
+\uD83D\uDCA1 Check MAIL_HOST/MAIL_PORT/MAIL_USERNAME/MAIL_PASSWORD/MAIL_ENCRYPTION in your .env.`);
+      else if (getErrorMessage(error).includes("not verified"))
+        console.log("\n\uD83D\uDCA1 Tip: make sure your domain is verified in SES (`buddy email:verify`).");
+    }
+    process.exit(0);
+  });
+  buddy.command("email:list", descriptions.list).action(async () => {
+    console.log(`
+\uD83D\uDCE7 Configured Mailboxes
+`);
+    const emailDomain = (emailConfig?.from?.address?.includes("@") ? emailConfig.from.address.split("@")[1] : void 0) || "stacksjs.com", mailboxes = emailConfig?.mailboxes || [];
+    console.log(`Domain: ${emailDomain}`);
+    console.log(`Default From: ${emailConfig?.from?.name} <${emailConfig?.from?.address}>`);
+    console.log("");
+    if (mailboxes.length === 0) {
+      console.log("No mailboxes configured.");
+      console.log(`
+\uD83D\uDCA1 Add mailboxes in config/email.ts:`);
+      console.log('   mailboxes: ["user@domain.com", "another@domain.com"]');
+    } else {
+      console.log("Mailboxes:");
+      for (const mailbox of mailboxes)
+        console.log(`  \uD83D\uDCEC ${mailbox}`);
+    }
+    console.log("");
+    process.exit(0);
+  });
+  buddy.command("email:logs", descriptions.logs).option("-n, --lines <count>", "Number of log lines to show", { default: "20" }).action(async (options) => {
+    console.log(`
+\uD83D\uDCE7 Email Processing Logs
+`);
+    await loadAwsCredentials();
+    try {
+      const { CloudWatchLogsClient } = await import("@stacksjs/ts-cloud"), logs = new CloudWatchLogsClient(process.env.AWS_REGION || "us-east-1"), logGroupName = `/aws/lambda/${(process.env.APP_NAME || "stacks").toLowerCase().replace(/[^a-z0-9-]/g, "-")}-inbound-email`;
+      console.log(`Log Group: ${logGroupName}`);
+      console.log(`Showing last ${options.lines} events...
+`);
+      const streams = await withTimeout(logs.describeLogStreams({
+        logGroupName,
+        orderBy: "LastEventTime",
+        descending: !0,
+        limit: 1
+      }));
+      if (!streams.logStreams || streams.logStreams.length === 0) {
+        console.log("No log streams found.");
+        console.log(`
+\uD83D\uDCA1 Logs will appear after emails are processed.`);
+        return;
+      }
+      const logStreamName = streams.logStreams[0].logStreamName;
+      if (!logStreamName) {
+        console.log("No log stream name found.");
+        return;
+      }
+      const events = await withTimeout(logs.getLogEvents({
+        logGroupName,
+        logStreamName,
+        limit: parseInt(options.lines || "20", 10)
+      }));
+      if (events.events && events.events.length > 0)
+        for (const event of events.events) {
+          const time = new Date(event.timestamp || 0).toISOString();
+          console.log(`[${time}] ${event.message}`);
+        }
+      else {
+        console.log("No log events found.");
+        console.log(`
+\uD83D\uDCA1 Logs will appear after emails are processed.`);
+      }
+    } catch (error) {
+      if (getErrorMessage(error).includes("ResourceNotFoundException") || getErrorMessage(error).includes("timed out"))
+        console.log("Log group not found or not accessible. No emails have been processed yet.");
+      else
+        console.error("Error fetching logs:", getErrorMessage(error));
+    }
+    process.exit(0);
+  });
+  buddy.command("email:status", descriptions.status).action(async () => {
+    console.log(`
+\uD83D\uDCE7 Email Server Status
+`);
+    await loadAwsCredentials();
+    try {
+      const { AWSCloudFormationClient } = await import("@stacksjs/ts-cloud"), cf = new AWSCloudFormationClient(process.env.AWS_REGION || "us-east-1"), stackName = `${(process.env.APP_NAME || "stacks").toLowerCase().replace(/[^a-z0-9-]/g, "-")}-cloud`, emailResources = (await withTimeout(cf.listStackResources(stackName))).StackResourceSummaries?.filter((r) => r.LogicalResourceId.includes("Email") || r.LogicalResourceId.includes("Inbound") || r.LogicalResourceId.includes("Outbound")) || [];
+      if (emailResources.length === 0) {
+        console.log("\u274C Email server not deployed.");
+        console.log("\n\uD83D\uDCA1 Run `buddy deploy` to set up email infrastructure.");
+        return;
+      }
+      console.log(`\u2705 Email Server Deployed
+`);
+      console.log("Resources:");
+      for (const resource of emailResources) {
+        const status = resource.ResourceStatus === "CREATE_COMPLETE" || resource.ResourceStatus === "UPDATE_COMPLETE" ? "\u2705" : "\u23F3";
+        console.log(`  ${status} ${resource.LogicalResourceId}`);
+      }
+      const emailOutputs = ((await withTimeout(cf.describeStacks({ stackName }))).Stacks?.[0]?.Outputs || []).filter((o) => o.OutputKey?.includes("Email"));
+      if (emailOutputs.length > 0) {
+        console.log(`
+Configuration:`);
+        for (const output of emailOutputs)
+          console.log(`  ${output.OutputKey}: ${output.OutputValue}`);
+      }
+    } catch (error) {
+      console.error("Error checking status:", getErrorMessage(error));
+    }
+    process.exit(0);
+  });
+  buddy.command("email:inbox [mailbox]", descriptions.inbox).option("-n, --limit <count>", "Number of emails to show", { default: "20" }).option("--raw <id>", "Show raw email content for a specific message ID").option("--bucket <name>", "S3 bucket name override").action(async (mailbox, options) => {
+    await loadAwsCredentials();
+    const region = process.env.AWS_REGION || "us-east-1", appName = (process.env.APP_NAME || "stacks").toLowerCase().replace(/[^a-z0-9-]/g, "-"), emailDomain = (emailConfig?.from?.address?.includes("@") ? emailConfig.from.address.split("@")[1] : void 0) || "stacksjs.com", bucketName = options?.bucket || `${appName}-production-email`, probe = await validateS3Bucket(bucketName, region);
+    if (!probe.ok) {
+      console.error(`
+\u274C ${probe.reason}
+\uD83D\uDCA1 ${probe.hint}
+`);
+      process.exit(ExitCode.FatalError);
+    }
+    if (options?.raw) {
+      console.log(`
+\uD83D\uDCE7 Fetching raw email: ${options.raw}
+`);
+      try {
+        const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(region);
+        let rawContent = null;
+        try {
+          rawContent = await withTimeout(s3.getObject(bucketName, `inbox/${options.raw}`));
+        } catch (e) {
+          if (mailbox) {
+            const [localPart, domain] = mailbox.includes("@") ? mailbox.split("@") : [mailbox, emailDomain], matchingKey = (await withTimeout(s3.listObjects({
+              bucket: bucketName,
+              prefix: `mailboxes/${domain}/${localPart}/`,
+              maxKeys: 1000
+            }))).Contents?.find((obj) => obj.Key.includes(options.raw) && obj.Key.endsWith("/raw.eml"));
+            if (matchingKey)
+              rawContent = await withTimeout(s3.getObject(bucketName, matchingKey.Key));
+          }
+        }
+        if (rawContent)
+          console.log(rawContent);
+        else
+          console.log("Email not found.");
+      } catch (error) {
+        console.error("Error fetching email:", getErrorMessage(error));
+      }
+      process.exit(0);
+      return;
+    }
+    const resolvedMailbox = mailbox || `chris@${emailDomain}`, [localPart, domain] = resolvedMailbox.includes("@") ? resolvedMailbox.split("@") : [resolvedMailbox, emailDomain];
+    console.log(`
+\uD83D\uDCE7 Inbox for ${localPart}@${domain}
+`);
+    console.log(`   Bucket: ${bucketName}`);
+    console.log("");
+    try {
+      const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(region), limit = parseInt(options?.limit || "20", 10), inboxKey = `mailboxes/${domain}/${localPart}/inbox.json`;
+      let inboxEmails = [], source = "mailboxes";
+      try {
+        const inboxData = await withTimeout(s3.getObject(bucketName, inboxKey));
+        if (inboxData)
+          try {
+            inboxEmails = JSON.parse(inboxData);
+            source = "mailboxes";
+          } catch {
+            inboxEmails = [];
+          }
+      } catch {}
+      if (inboxEmails.length === 0) {
+        console.log(`   No processed inbox found. Scanning raw emails from inbox/ ...
+`);
+        source = "raw";
+        try {
+          const objects = (await withTimeout(s3.listObjects({
+            bucket: bucketName,
+            prefix: "inbox/",
+            maxKeys: limit
+          }))).Contents || [];
+          if (objects.length === 0) {
+            const objects2 = (await withTimeout(s3.listObjects({
+              bucket: bucketName,
+              prefix: "incoming/",
+              maxKeys: limit
+            }))).Contents || [];
+            objects.push(...objects2);
+          }
+          for (const obj of objects.slice(0, limit))
+            try {
+              const rawEmail = await withTimeout(s3.getObject(bucketName, obj.Key));
+              if (!rawEmail)
+                continue;
+              const headers = parseRawEmailHeaders(rawEmail);
+              inboxEmails.push({
+                messageId: obj.Key.split("/").pop() || obj.Key,
+                from: headers.from || "unknown",
+                subject: headers.subject || "No Subject",
+                date: headers.date || obj.LastModified || "unknown",
+                path: obj.Key
+              });
+            } catch (parseErr) {
+              inboxEmails.push({
+                messageId: obj.Key.split("/").pop() || obj.Key,
+                from: "unknown",
+                subject: "(could not parse)",
+                date: obj.LastModified || "unknown",
+                path: obj.Key
+              });
+            }
+        } catch (listErr) {
+          console.error("Error listing emails:", listErr.message);
+        }
+      }
+      if (inboxEmails.length === 0) {
+        console.log("   No emails found.");
+        console.log(`
+   Waiting for emails to arrive at inbox/ in the S3 bucket.`);
+        console.log("   Send an email to an @" + domain + " address to test.");
+        process.exit(0);
+        return;
+      }
+      console.log(`   Source: ${source} (${inboxEmails.length} emails)
+`);
+      console.log("   %-4s  %-20s  %-30s  %s", "#", "Date", "From", "Subject");
+      console.log("   " + "-".repeat(90));
+      for (let i = 0;i < Math.min(inboxEmails.length, limit); i++) {
+        const e = inboxEmails[i], date = e.date ? new Date(e.date).toLocaleDateString("en-US", { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" }) : "?", from = (e.from || "").substring(0, 20).padEnd(20), subject = (e.subject || "").substring(0, 40), readMark = e.read === !1 ? "*" : " ";
+        console.log(`   ${readMark}${String(i + 1).padStart(3)}  ${date.padEnd(20)}  ${from}  ${subject}`);
+      }
+      console.log("");
+      console.log("   * = unread");
+      console.log(`
+   View raw email: buddy email:inbox ${resolvedMailbox} --raw <messageId>`);
+    } catch (error) {
+      console.error("Error reading inbox:", getErrorMessage(error));
+    }
+    process.exit(0);
+  });
+  buddy.command("email:reprocess", descriptions.reprocess).option("--bucket <name>", "S3 bucket name override").option("--prefix <prefix>", "S3 prefix to scan", { default: "inbox/" }).option("--domain <domain>", "Email domain", { default: "stacksjs.com" }).action(async (options) => {
+    await loadAwsCredentials();
+    const region = process.env.AWS_REGION || "us-east-1", appName = (process.env.APP_NAME || "stacks").toLowerCase().replace(/[^a-z0-9-]/g, "-"), bucketName = options?.bucket || `${appName}-production-email`, prefix = options?.prefix || "inbox/", domain = options?.domain || "stacksjs.com";
+    console.log(`
+\uD83D\uDCE7 Reprocessing emails from s3://${bucketName}/${prefix}
+`);
+    try {
+      const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(region), objects = (await withTimeout(s3.listObjects({
+        bucket: bucketName,
+        prefix,
+        maxKeys: 1000
+      }), 60000)).Contents || [];
+      console.log(`   Found ${objects.length} raw emails to process
+`);
+      const inboxes = {};
+      let processed = 0;
+      for (const obj of objects) {
+        if (!obj.Key || obj.Key.endsWith("/"))
+          continue;
+        try {
+          const rawEmail = await withTimeout(s3.getObject(bucketName, obj.Key), 15000);
+          if (!rawEmail)
+            continue;
+          const headers = parseRawEmailHeaders(rawEmail), messageId = obj.Key.split("/").pop() || obj.Key, from = extractEmailAddress(headers.from || ""), fromName = extractEmailName(headers.from || ""), toList = (headers.to || "").split(",").map((s) => s.trim()).filter(Boolean), subject = headers.subject || "No Subject", date = headers.date || (obj.LastModified ? new Date(obj.LastModified).toISOString() : new Date().toISOString());
+          let preview = "";
+          const bodyStart = rawEmail.indexOf(`\r
+\r
+`);
+          if (bodyStart > 0)
+            preview = rawEmail.substring(bodyStart + 4, bodyStart + 500).replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim().substring(0, 200);
+          const recipients = toList.length > 0 ? toList : [`unknown@${domain}`];
+          for (const recipient of recipients) {
+            const recipientEmail = extractEmailAddress(recipient);
+            if (!recipientEmail.endsWith(`@${domain}`))
+              continue;
+            const [localPart] = recipientEmail.split("@"), d = new Date(date), year = d.getFullYear(), month = String(d.getMonth() + 1).padStart(2, "0"), day = String(d.getDate()).padStart(2, "0"), emailPath = `mailboxes/${domain}/${localPart}/${year}/${month}/${day}/${messageId}`;
+            await s3.putObject({
+              bucket: bucketName,
+              key: `${emailPath}/raw.eml`,
+              body: rawEmail,
+              contentType: "message/rfc822"
+            });
+            const metadata = { messageId, from, fromName, to: recipientEmail, subject, date, preview, hasAttachments: !1 };
+            await s3.putObject({
+              bucket: bucketName,
+              key: `${emailPath}/metadata.json`,
+              body: JSON.stringify(metadata, null, 2),
+              contentType: "application/json"
+            });
+            const inboxKey = `${domain}/${localPart}`;
+            if (!inboxes[inboxKey])
+              inboxes[inboxKey] = [];
+            inboxes[inboxKey].push({
+              messageId,
+              from,
+              fromName,
+              to: recipientEmail,
+              subject,
+              date,
+              read: !1,
+              preview,
+              hasAttachments: !1,
+              path: emailPath
+            });
+          }
+          processed++;
+          if (processed % 5 === 0)
+            console.log(`   Processed ${processed}/${objects.length} emails...`);
+        } catch (emailErr) {
+          console.log(`   Skipping ${obj.Key}: ${emailErr.message}`);
+        }
+      }
+      for (const [key, emails] of Object.entries(inboxes)) {
+        const [d, localPart] = key.split("/"), inboxJsonKey = `mailboxes/${d}/${localPart}/inbox.json`;
+        emails.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+        let existing = [];
+        try {
+          const existingData = await s3.getObject(bucketName, inboxJsonKey);
+          if (existingData)
+            try {
+              existing = JSON.parse(existingData);
+            } catch {
+              existing = [];
+            }
+        } catch {}
+        const existingIds = new Set(existing.map((e) => e.messageId)), newEmails = emails.filter((e) => !existingIds.has(e.messageId)), merged = [...newEmails, ...existing].slice(0, 1000);
+        await s3.putObject({
+          bucket: bucketName,
+          key: inboxJsonKey,
+          body: JSON.stringify(merged, null, 2),
+          contentType: "application/json"
+        });
+        console.log(`   Updated inbox for ${localPart}@${d}: ${newEmails.length} new emails (${merged.length} total)`);
+      }
+      console.log(`
+   Done! Processed ${processed} emails.`);
+    } catch (error) {
+      console.error("Error reprocessing:", getErrorMessage(error));
+    }
+    process.exit(0);
+  });
+  onUnknownSubcommand(buddy, "email");
+}
+function parseRawEmailHeaders(rawEmail) {
+  const headers = {}, lines = rawEmail.split(/\r?\n/);
+  let currentKey = "", currentValue = "";
+  for (const line of lines) {
+    if (line === "")
+      break;
+    if (/^\s/.test(line) && currentKey) {
+      currentValue += " " + line.trim();
+      headers[currentKey] = currentValue;
+    } else {
+      const match = line.match(/^([^:]+):\s*(.*)$/);
+      if (match) {
+        currentKey = match[1].toLowerCase();
+        currentValue = match[2] ?? "";
+        headers[currentKey] = currentValue;
+      }
+    }
+  }
+  return headers;
+}
+function extractEmailAddress(str) {
+  if (!str)
+    return "";
+  return (str.match(/<([^>]+)>/)?.[1] ?? str).toLowerCase().trim();
+}
+function extractEmailName(str) {
+  if (!str)
+    return "";
+  return str.match(/^"?([^"<]+)"?\s*</)?.[1]?.trim() ?? "";
+}

package/dist/commands/env.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function env(buddy: CLI): void;