@agenticmail/cli 0.5.57

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { AccountManager, AddressInfo, Agent, AgenticMailClient, AgenticMailClientOptions, AgenticMailConfig, Attachment, CloudflareClient, CreateAgentOptions, DNSConfigurator, DnsRecord, DnsSetupResult, DomainInfo, DomainManager, DomainModeConfig, DomainPurchaseResult, DomainPurchaser, DomainSearchResult, DomainSetupResult, EmailEnvelope, EmailSearchIndex, GatewayConfig, GatewayManager, GatewayManagerOptions, GatewayMode, GatewayStatus, InboundEmail, InboxEvent, InboxExpungeEvent, InboxFlagsEvent, InboxNewEvent, InboxWatcher, InboxWatcherOptions, MailReceiver, MailReceiverOptions, MailSender, MailSenderOptions, MailboxInfo, ParsedAttachment, ParsedEmail, PurchasedDomain, RELAY_PRESETS, RelayConfig, RelayGateway, RelayProvider, SearchCriteria, SearchableEmail, SendMailOptions, SendResult, StalwartAdmin, StalwartAdminOptions, StalwartPrincipal, TunnelConfig, TunnelManager, WatcherOptions, closeDatabase, createTestDatabase, ensureDataDir, getDatabase, parseEmail, resolveConfig, saveConfig } from '@agenticmail/core';

package/dist/index.js

@@ -0,0 +1,43 @@
+// src/index.ts
+import { AgenticMailClient } from "@agenticmail/core";
+import { resolveConfig, ensureDataDir, saveConfig } from "@agenticmail/core";
+import { StalwartAdmin } from "@agenticmail/core";
+import { AccountManager } from "@agenticmail/core";
+import { MailSender } from "@agenticmail/core";
+import { MailReceiver } from "@agenticmail/core";
+import { parseEmail } from "@agenticmail/core";
+import { InboxWatcher } from "@agenticmail/core";
+import { getDatabase, closeDatabase, createTestDatabase } from "@agenticmail/core";
+import { EmailSearchIndex } from "@agenticmail/core";
+import { DomainManager } from "@agenticmail/core";
+import { GatewayManager } from "@agenticmail/core";
+import { RelayGateway } from "@agenticmail/core";
+import { CloudflareClient } from "@agenticmail/core";
+import { DomainPurchaser } from "@agenticmail/core";
+import { DNSConfigurator } from "@agenticmail/core";
+import { TunnelManager } from "@agenticmail/core";
+import { RELAY_PRESETS } from "@agenticmail/core";
+export {
+  AccountManager,
+  AgenticMailClient,
+  CloudflareClient,
+  DNSConfigurator,
+  DomainManager,
+  DomainPurchaser,
+  EmailSearchIndex,
+  GatewayManager,
+  InboxWatcher,
+  MailReceiver,
+  MailSender,
+  RELAY_PRESETS,
+  RelayGateway,
+  StalwartAdmin,
+  TunnelManager,
+  closeDatabase,
+  createTestDatabase,
+  ensureDataDir,
+  getDatabase,
+  parseEmail,
+  resolveConfig,
+  saveConfig
+};

package/dist/ws-chat-OVLCQILI.js

@@ -0,0 +1,242 @@
+// src/ws-chat.ts
+import { createPrivateKey, createPublicKey, sign, createHash, generateKeyPairSync, randomUUID } from "crypto";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+var PROTOCOL_VERSION = 3;
+function base64UrlEncode(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function derivePublicKeyRaw(publicKeyPem) {
+  const key = createPublicKey(publicKeyPem);
+  const spki = key.export({ type: "spki", format: "der" });
+  return Buffer.from(spki).subarray(-32);
+}
+function fingerprintPublicKey(publicKeyPem) {
+  const raw = derivePublicKeyRaw(publicKeyPem);
+  return createHash("sha256").update(raw).digest("hex");
+}
+function loadOrCreateIdentity() {
+  const homedir = process.env.HOME || process.env.USERPROFILE || "";
+  const filePath = join(homedir, ".agenticmail", "device-identity.json");
+  try {
+    if (existsSync(filePath)) {
+      const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+      if (parsed?.version === 1 && parsed.privateKeyPem && parsed.publicKeyPem) {
+        return {
+          deviceId: fingerprintPublicKey(parsed.publicKeyPem),
+          publicKeyPem: parsed.publicKeyPem,
+          privateKeyPem: parsed.privateKeyPem
+        };
+      }
+    }
+  } catch {
+  }
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" });
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
+  const deviceId = fingerprintPublicKey(publicKeyPem);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify({ version: 1, deviceId, publicKeyPem, privateKeyPem, createdAtMs: Date.now() }, null, 2) + "\n", { mode: 384 });
+  return { deviceId, publicKeyPem, privateKeyPem };
+}
+function signPayload(privateKeyPem, payload) {
+  const key = createPrivateKey(privateKeyPem);
+  return base64UrlEncode(sign(null, Buffer.from(payload, "utf8"), key));
+}
+var WsChat = class {
+  ws = null;
+  reqId = 0;
+  connected = false;
+  pendingRequests = /* @__PURE__ */ new Map();
+  chatResolve = null;
+  chatBuffer = "";
+  onDelta = null;
+  opts;
+  connectResolve = null;
+  connectReject = null;
+  identity;
+  connectNonce;
+  constructor(opts) {
+    this.opts = opts;
+    this.identity = loadOrCreateIdentity();
+  }
+  sendConnect() {
+    const id = String(++this.reqId);
+    this.pendingRequests.set(id, {
+      resolve: () => {
+        this.connected = true;
+        this.connectResolve?.();
+      },
+      reject: (err) => {
+        this.connectReject?.(err);
+      }
+    });
+    const scopes = ["operator.admin", "operator.write", "operator.read"];
+    const signedAtMs = Date.now();
+    const nonce = this.connectNonce;
+    const version = nonce ? "v2" : "v1";
+    const payloadParts = [
+      version,
+      this.identity.deviceId,
+      "gateway-client",
+      "backend",
+      "operator",
+      scopes.join(","),
+      String(signedAtMs),
+      this.opts.token
+    ];
+    if (version === "v2") payloadParts.push(nonce ?? "");
+    const payloadStr = payloadParts.join("|");
+    const signature = signPayload(this.identity.privateKeyPem, payloadStr);
+    this.ws.send(JSON.stringify({
+      type: "req",
+      id,
+      method: "connect",
+      params: {
+        minProtocol: PROTOCOL_VERSION,
+        maxProtocol: PROTOCOL_VERSION,
+        client: {
+          id: "gateway-client",
+          displayName: "AgenticMail Chat",
+          version: "1.0.0",
+          platform: process.platform,
+          mode: "backend"
+        },
+        caps: [],
+        auth: { token: this.opts.token },
+        role: "operator",
+        scopes,
+        device: {
+          id: this.identity.deviceId,
+          publicKey: base64UrlEncode(derivePublicKeyRaw(this.identity.publicKeyPem)),
+          signature,
+          signedAt: signedAtMs,
+          nonce
+        }
+      }
+    }));
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.connectResolve = resolve;
+      this.connectReject = reject;
+      const url = this.opts.gatewayUrl.replace(/^http/, "ws");
+      this.ws = new WebSocket(url);
+      const timeout = setTimeout(() => {
+        reject(new Error("Connection timeout"));
+        this.ws?.close();
+      }, 15e3);
+      this.ws.onopen = () => {
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(typeof event.data === "string" ? event.data : event.data.toString());
+          if (data.type === "event" && data.event === "connect.challenge") {
+            this.connectNonce = data.payload?.nonce;
+            this.sendConnect();
+            return;
+          }
+          this.handleMessage(data);
+        } catch {
+        }
+      };
+      this.ws.onerror = () => {
+        clearTimeout(timeout);
+        reject(new Error("Connection failed"));
+      };
+      this.ws.onclose = () => {
+        clearTimeout(timeout);
+        this.connected = false;
+        if (this.chatResolve) {
+          this.chatResolve({ text: this.chatBuffer, done: true, error: "connection closed" });
+          this.chatResolve = null;
+        }
+      };
+      const origResolve = this.connectResolve;
+      this.connectResolve = () => {
+        clearTimeout(timeout);
+        origResolve?.();
+      };
+    });
+  }
+  handleMessage(data) {
+    if (data.type === "res" && typeof data.id === "string") {
+      const pending = this.pendingRequests.get(data.id);
+      if (pending) {
+        this.pendingRequests.delete(data.id);
+        if (data.ok === false) {
+          pending.reject(new Error(data.error?.message || "request failed"));
+        } else {
+          pending.resolve(data.result ?? data);
+        }
+      }
+      return;
+    }
+    if (data.type === "event" || data.type === "evt") {
+      const event = data.event;
+      const payload = data.payload;
+      if (event === "chat") {
+        const text = payload?.message?.content?.[0]?.text ?? "";
+        const state = payload?.state;
+        if (state === "delta" && text) {
+          this.chatBuffer = text;
+          this.onDelta?.(text);
+        }
+        if (state === "final") {
+          if (text) this.chatBuffer = text;
+          if (this.chatResolve) {
+            this.chatResolve({ text: this.chatBuffer, done: true });
+            this.chatResolve = null;
+          }
+        }
+      }
+    }
+  }
+  async send(message, opts) {
+    if (!this.connected || !this.ws) throw new Error("Not connected");
+    this.chatBuffer = "";
+    this.onDelta = opts?.onDelta ?? null;
+    const id = String(++this.reqId);
+    const timeoutMs = opts?.timeoutMs ?? 12e4;
+    return new Promise((resolve, reject) => {
+      this.chatResolve = resolve;
+      const timer = setTimeout(() => {
+        if (this.chatResolve) {
+          this.chatResolve({ text: this.chatBuffer, done: true, error: "timeout" });
+          this.chatResolve = null;
+        }
+      }, timeoutMs);
+      this.pendingRequests.set(id, {
+        resolve: () => {
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          this.chatResolve = null;
+          reject(err);
+        }
+      });
+      const idempotencyKey = randomUUID();
+      this.ws.send(JSON.stringify({
+        type: "req",
+        id,
+        method: "chat.send",
+        params: {
+          message,
+          sessionKey: opts?.sessionKey ?? this.opts.sessionKey ?? "agenticmail-chat",
+          idempotencyKey
+        }
+      }));
+    });
+  }
+  close() {
+    this.ws?.close();
+    this.ws = null;
+    this.connected = false;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+};
+export {
+  WsChat
+};

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@agenticmail/cli",
+  "version": "0.5.57",
+  "description": "Email and SMS infrastructure for AI agents — the first platform to give agents real email addresses and phone numbers",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "agenticmail": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "REFERENCE.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "test": "vitest run --passWithNoTests",
+    "preuninstall": "node scripts/uninstall.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@agenticmail/api": "^0.5.56",
+    "@agenticmail/core": "^0.5.0",
+    "json5": "^2.2.3"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agenticmail/agenticmail.git",
+    "directory": "agenticmail"
+  },
+  "homepage": "https://github.com/agenticmail/agenticmail",
+  "bugs": "https://github.com/agenticmail/agenticmail/issues",
+  "keywords": [
+    "email",
+    "sms",
+    "phone",
+    "ai",
+    "agent",
+    "mail",
+    "smtp",
+    "imap",
+    "mcp",
+    "ai-agent",
+    "agenticmail",
+    "llm",
+    "gateway",
+    "cloudflare",
+    "google-voice",
+    "text-message",
+    "verification-code",
+    "openclaw"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Ope Olatunji",
+  "license": "MIT"
+}

package/scripts/uninstall.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+/**
+ * Cleanup script that runs on `npm uninstall agenticmail`.
+ *
+ * 1. Unloads & removes the launchd / systemd auto-start service
+ * 2. Stops & removes the agenticmail-stalwart Docker container
+ * 3. Cleans agenticmail entries from OpenClaw config
+ * 4. Removes ~/.agenticmail data directory
+ */
+
+import { execSync, execFileSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync, rmSync, unlinkSync, lstatSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, platform } from 'node:os';
+
+const home = homedir();
+const os = platform();
+
+function log(msg) { console.log(`[agenticmail] ${msg}`); }
+function tryExec(cmd, opts = {}) { try { execSync(cmd, { timeout: 15_000, stdio: 'ignore', ...opts }); } catch { /* ignore */ } }
+
+// ── 1. Unload auto-start service ─────────────────────────────────
+
+if (os === 'darwin') {
+  const plist = join(home, 'Library', 'LaunchAgents', 'com.agenticmail.server.plist');
+  if (existsSync(plist)) {
+    log('Unloading launchd service...');
+    tryExec(`launchctl bootout gui/$(id -u) "${plist}"`);
+    try { unlinkSync(plist); } catch { /* ignore */ }
+  }
+} else if (os === 'linux') {
+  const unit = 'agenticmail.service';
+  tryExec(`systemctl --user stop ${unit}`);
+  tryExec(`systemctl --user disable ${unit}`);
+  const unitPath = join(home, '.config', 'systemd', 'user', unit);
+  if (existsSync(unitPath)) {
+    try { unlinkSync(unitPath); } catch { /* ignore */ }
+    tryExec('systemctl --user daemon-reload');
+  }
+}
+
+// ── 2. Stop Docker container ──────────────────────────────────────
+
+try {
+  const ps = execFileSync('docker', ['ps', '-a', '--filter', 'name=agenticmail-stalwart', '--format', '{{.Names}}'],
+    { timeout: 10_000, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+  if (ps.includes('agenticmail-stalwart')) {
+    log('Stopping mail server container...');
+    tryExec('docker rm -f agenticmail-stalwart');
+  }
+} catch { /* docker not available — skip */ }
+
+// ── 3. Clean OpenClaw config ──────────────────────────────────────
+
+const openclawConfig = join(home, '.openclaw', 'openclaw.json');
+if (existsSync(openclawConfig)) {
+  try {
+    const raw = readFileSync(openclawConfig, 'utf-8');
+    const config = JSON.parse(raw);
+    let changed = false;
+
+    // Remove plugins.entries.agenticmail
+    if (config.plugins?.entries?.agenticmail) {
+      delete config.plugins.entries.agenticmail;
+      changed = true;
+      if (Object.keys(config.plugins.entries).length === 0) delete config.plugins.entries;
+    }
+
+    // Remove our path from plugins.load.paths
+    if (Array.isArray(config.plugins?.load?.paths)) {
+      const before = config.plugins.load.paths.length;
+      config.plugins.load.paths = config.plugins.load.paths.filter(
+        (p) => !p.includes('@agenticmail')
+      );
+      if (config.plugins.load.paths.length !== before) changed = true;
+      if (config.plugins.load.paths.length === 0) {
+        delete config.plugins.load.paths;
+        if (config.plugins.load && Object.keys(config.plugins.load).length === 0) delete config.plugins.load;
+      }
+    }
+
+    if (changed) {
+      writeFileSync(openclawConfig, JSON.stringify(config, null, 2) + '\n');
+      log('Cleaned OpenClaw config');
+    }
+  } catch { /* don't fail uninstall */ }
+}
+
+// ── 4. Remove ~/.agenticmail ──────────────────────────────────────
+
+const dataDir = join(home, '.agenticmail');
+if (existsSync(dataDir)) {
+  // Safety: verify it's not a symlink pointing outside home (symlink attack prevention)
+  try {
+    const stat = lstatSync(dataDir);
+    if (stat.isSymbolicLink()) {
+      const realPath = realpathSync(dataDir);
+      if (!realPath.startsWith(home)) {
+        log(`WARNING: ~/.agenticmail is a symlink to ${realPath} (outside home dir) — skipping removal`);
+      } else {
+        log('Removing ~/.agenticmail/ (symlink) ...');
+        try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
+      }
+    } else {
+      log('Removing ~/.agenticmail/ ...');
+      try { rmSync(dataDir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  } catch { /* stat failed — skip */ }
+}
+
+log('Uninstall complete.');