@agentdomain/eliza-plugin 0.7.0 → 0.7.1

package/README.md

@@ -11,12 +11,13 @@ The plugin gives Eliza agents a complete AgentDomain lifecycle surface:
 - Registration quote and x402 registration
 - Registry discovery
 - Agent email send/list/batch, monthly usage, signed inbound webhooks, primary address updates, and Starter/Pro/Enterprise aliases
-- Typed DNS management for all 13 Spaceship-supported types, including capabilities, revision-safe batches, and BIND import/export
+- Typed DNS management for all 13 supported types, including capabilities, revision-safe batches, and BIND import/export
 - SSL repair/reconfiguration
 - RenewalVault status, funding, and auto-renew
 - Per-agent Premium Plan status and upgrades
 
-Configure `AGENTDOMAIN_API_URL` only if you need a custom endpoint. The default is `https://agentdomain.app/api/v1`.
+Configure `AGENTDOMAIN_API_URL` only if you need a custom endpoint. The default is
+`https://api.agentdomain.app/api/v1`.
 
 Set `AGENTDOMAIN_BUILDER_CODE` to your public ERC-8021 app identifier whenever
 the runtime can submit direct Base writes. The value is not a private key.

package/dist/index.js

@@ -5,6 +5,7 @@ import { createPublicClient, createWalletClient, http } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { base, baseSepolia } from 'viem/chains';
 import { z } from 'zod';
+import { extractEmailAddresses, extractFencedBlock, parseCompactQuantity, readLabeledEmail, readLabeledEmailUsername, readLabeledRemainder, } from './text-parsing.js';
 /** Builds the attributed direct calldata used by Eliza's post-registration auto-renew step. */
 export function encodeElizaAutoRenewCalldata(tokenId, builderCode) {
     if (!builderCode) {
@@ -42,8 +43,6 @@ function getClients(runtime, opts = {}) {
 const TLD_PATTERN = new RegExp(String.raw `([a-z0-9-]{3,63})\.([a-z]{2,20})\b`, 'i');
 const UUID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i;
 const AMOUNT_PATTERN = /\$?\s*(\d+(?:\.\d{1,6})?)\s*(?:usdc)?/i;
-const EMAIL_PATTERN = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i;
-const EMAIL_GLOBAL_PATTERN = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
 const EMAIL_USERNAME_PATTERN = /^[a-z0-9](?:[a-z0-9._+-]{0,62}[a-z0-9])?$/;
 const registerSchema = z.object({
     preferredName: z.string(),
@@ -108,9 +107,9 @@ function parseRegistrationPlan(lower) {
 function parsePlan(text) {
     const lower = text.toLowerCase();
     if (lower.includes('enterprise')) {
-        const match = lower.match(/(\d+(?:\.\d+)?)\s*(k|m)/);
-        const monthly = match
-            ? Math.round(Number(match[1]) * (match[2] === 'm' ? 1_000_000 : 1_000))
+        const quantity = parseCompactQuantity(lower);
+        const monthly = quantity
+            ? Math.round(quantity.value * (quantity.suffix === 'm' ? 1_000_000 : 1_000))
             : 100_000;
         return {
             plan: 'enterprise',
@@ -123,27 +122,29 @@ function parseDnsRecord(text) {
     const lower = text.toLowerCase();
     const typeMatch = text.match(/\b(A|AAAA|ALIAS|CAA|CNAME|HTTPS|MX|NS|PTR|SRV|SVCB|TLSA|TXT)\b/i);
     const nameMatch = text.match(/\bname[:=]\s*([^\s]+)/i);
-    const valueMatch = text.match(/\bvalue[:=]\s*(.+?)(?=\s+\b(?:ttl|priority)[:=]|$)/i);
+    const value = readLabeledRemainder(text, ['value'], {
+        stopLabels: ['ttl', 'priority'],
+    });
     const ttlMatch = text.match(/\bttl[:=]\s*(\d+)/i);
     const priorityMatch = text.match(/\bpriority[:=]\s*(\d+)/i);
     const parsed = dnsRecordSchema.parse({
         type: typeMatch?.[1]?.toUpperCase() ?? (lower.includes('txt') ? 'TXT' : 'A'),
         name: nameMatch?.[1] ?? '@',
-        value: valueMatch?.[1]?.trim() ?? text.match(/\b(?:\d{1,3}\.){3}\d{1,3}\b/)?.[0] ?? '',
+        value: value ?? text.match(/\b(?:\d{1,3}\.){3}\d{1,3}\b/)?.[0] ?? '',
         ttl: ttlMatch ? Number(ttlMatch[1]) : 3600,
         priority: priorityMatch ? Number(priorityMatch[1]) : undefined,
     });
     return parsed;
 }
 function parseDnsRecordsJson(text) {
-    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1];
+    const fenced = extractFencedBlock(text, ['json']);
     const json = fenced ?? text.slice(text.indexOf('['), text.lastIndexOf(']') + 1);
     if (!json)
         throw new Error('A JSON array of DNS records is required');
     return z.array(sharedDnsRecordSchema).min(1).max(200).parse(JSON.parse(json));
 }
 function parseZoneFile(text) {
-    const fenced = text.match(/```(?:bind|zone|dns)?\s*([\s\S]*?)```/i)?.[1];
+    const fenced = extractFencedBlock(text, ['bind', 'zone', 'dns']);
     if (!fenced?.trim())
         throw new Error('Put the BIND zone records inside a fenced code block');
     return fenced.trim();
@@ -162,20 +163,20 @@ function requireDnsRevision(value) {
     return value;
 }
 function parseEmailUsername(text) {
-    const explicit = text.match(/\b(?:email\s+username|primary\s+email|username|alias)[:=]?\s*([a-z0-9._+-]{1,64})/i)?.[1] ?? text.match(EMAIL_PATTERN)?.[0]?.split('@')[0];
+    const explicit = readLabeledEmailUsername(text, ['email username', 'primary email', 'username', 'alias']) ??
+        extractEmailAddresses(text)[0]?.split('@')[0];
     const username = explicit?.trim().toLowerCase();
     return username && EMAIL_USERNAME_PATTERN.test(username) ? username : null;
 }
 function parseEmailRequest(text) {
-    const fromAddress = text.match(/\bfrom[:=]\s*([A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,})/i)?.[1];
-    const explicitTo = text.match(/\bto[:=]\s*([A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,})/i)?.[1];
-    const emails = text.match(EMAIL_GLOBAL_PATTERN) ?? [];
+    const fromAddress = readLabeledEmail(text, ['from']);
+    const explicitTo = readLabeledEmail(text, ['to']);
+    const emails = extractEmailAddresses(text);
     const to = explicitTo ?? emails.find((email) => email.toLowerCase() !== fromAddress?.toLowerCase());
     if (!to)
         throw new Error('Recipient email address is required');
-    const subject = text.match(/\bsubject[:=]\s*([^|]+)/i)?.[1]?.trim() ?? 'AgentDomain message';
-    const body = text.match(/\b(?:text|body|message)[:=]\s*([\s\S]+)/i)?.[1]?.trim() ??
-        text.replace(to, '').trim();
+    const subject = readLabeledRemainder(text, ['subject'], { stopCharacter: '|' }) ?? 'AgentDomain message';
+    const body = readLabeledRemainder(text, ['text', 'body', 'message']) ?? text.replace(to, '').trim();
     return { to, fromAddress, subject, text: body || 'Hello from AgentDomain.' };
 }
 export const quoteRegistrationAction = {
@@ -412,7 +413,7 @@ export const deleteEmailAliasAction = {
     handler: async (runtime, message) => {
         const { ad } = getClients(runtime);
         const agentId = requireAgentId(message.content.text);
-        const emailAddress = message.content.text.match(EMAIL_PATTERN)?.[0];
+        const emailAddress = extractEmailAddresses(message.content.text)[0];
         if (!emailAddress)
             throw new Error('Full alias email address is required');
         const result = await ad.deleteEmailAlias(agentId, emailAddress);
@@ -470,7 +471,7 @@ export const enableAutoRenewAction = {
 };
 export const reconfigureSslAction = {
     name: 'RECONFIGURE_SSL',
-    description: 'Rebuild the Cloudflare SaaS SSL hostname and sync Spaceship DNS validation records for an AgentDomain identity.',
+    description: 'Rebuild the managed SSL hostname and sync DNS validation records for an AgentDomain identity.',
     similes: ['FIX_SSL', 'REPAIR_SSL', 'SYNC_SSL'],
     examples: [],
     validate: async (runtime) => Boolean(runtime.getSetting('AGENT_PRIVATE_KEY')),
@@ -509,7 +510,7 @@ export const dnsCapabilitiesAction = {
         const { ad } = getClients(runtime);
         const result = await ad.getDnsCapabilities(requireAgentId(message.content.text));
         return {
-            text: `AgentDomain supports ${result.supportedTypes.length} Spaceship DNS record types.`,
+            text: `AgentDomain supports ${result.supportedTypes.length} DNS record types.`,
             data: result,
         };
     },

package/dist/text-parsing.d.ts

@@ -0,0 +1,14 @@
+export interface CompactQuantity {
+    value: number;
+    suffix: 'k' | 'm';
+}
+export declare function readLabeledRemainder(text: string, labels: readonly string[], options?: {
+    requireSeparator?: boolean;
+    stopCharacter?: string;
+    stopLabels?: readonly string[];
+}): string | undefined;
+export declare function readLabeledEmailUsername(text: string, labels: readonly string[]): string | undefined;
+export declare function extractEmailAddresses(text: string): string[];
+export declare function readLabeledEmail(text: string, labels: readonly string[]): string | undefined;
+export declare function extractFencedBlock(text: string, optionalLanguages: readonly string[]): string | undefined;
+export declare function parseCompactQuantity(text: string): CompactQuantity | undefined;

package/dist/text-parsing.js

@@ -0,0 +1,226 @@
+function isAsciiWhitespace(character) {
+    return character === ' ' || character === '\t' || character === '\r' || character === '\n';
+}
+function isAsciiDigit(character) {
+    return character !== undefined && character >= '0' && character <= '9';
+}
+function isAsciiLetter(character) {
+    return (character !== undefined &&
+        ((character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z')));
+}
+function isAsciiAlphanumeric(character) {
+    return isAsciiDigit(character) || isAsciiLetter(character);
+}
+function isWordCharacter(character) {
+    return isAsciiAlphanumeric(character) || character === '_';
+}
+function isEmailLocalCharacter(character) {
+    return (isAsciiAlphanumeric(character) ||
+        character === '.' ||
+        character === '_' ||
+        character === '%' ||
+        character === '+' ||
+        character === '-');
+}
+function isEmailDomainCharacter(character) {
+    return isAsciiAlphanumeric(character) || character === '.' || character === '-';
+}
+function skipWhitespace(text, start) {
+    let cursor = start;
+    while (cursor < text.length && isAsciiWhitespace(text[cursor]))
+        cursor += 1;
+    return cursor;
+}
+function asciiCharactersEqual(left, right) {
+    if (left === right)
+        return true;
+    if (left === undefined || !isAsciiLetter(left) || !isAsciiLetter(right))
+        return false;
+    return (left.charCodeAt(0) | 32) === (right.charCodeAt(0) | 32);
+}
+function matchesAsciiCaseInsensitive(text, pattern, start) {
+    if (start + pattern.length > text.length)
+        return false;
+    for (let offset = 0; offset < pattern.length; offset += 1) {
+        if (!asciiCharactersEqual(text[start + offset], pattern[offset]))
+            return false;
+    }
+    return true;
+}
+function findLabeledValue(text, labels, requireSeparator, fromIndex = 0, requireWhitespaceBefore = false) {
+    let best = null;
+    for (const label of labels) {
+        let searchFrom = fromIndex;
+        while (searchFrom + label.length <= text.length) {
+            if (!matchesAsciiCaseInsensitive(text, label, searchFrom)) {
+                searchFrom += 1;
+                continue;
+            }
+            const labelStart = searchFrom;
+            const labelEnd = labelStart + label.length;
+            const hasStartBoundary = labelStart === 0 || !isWordCharacter(text[labelStart - 1]);
+            const hasEndBoundary = labelEnd === text.length || !isWordCharacter(text[labelEnd]);
+            const hasRequiredWhitespace = !requireWhitespaceBefore ||
+                labelStart === fromIndex ||
+                isAsciiWhitespace(text[labelStart - 1]);
+            if (hasStartBoundary && hasEndBoundary && hasRequiredWhitespace) {
+                let valueStart = skipWhitespace(text, labelEnd);
+                const hasSeparator = text[valueStart] === ':' || text[valueStart] === '=';
+                if (hasSeparator)
+                    valueStart = skipWhitespace(text, valueStart + 1);
+                if (!requireSeparator || hasSeparator) {
+                    if (best === null || labelStart < best.labelStart)
+                        best = { labelStart, valueStart };
+                    break;
+                }
+            }
+            searchFrom += 1;
+        }
+    }
+    return best;
+}
+export function readLabeledRemainder(text, labels, options = {}) {
+    const match = findLabeledValue(text, labels, options.requireSeparator ?? true);
+    if (match === null)
+        return undefined;
+    let valueEnd = text.length;
+    if (options.stopCharacter) {
+        const stop = text.indexOf(options.stopCharacter, match.valueStart);
+        if (stop >= 0)
+            valueEnd = stop;
+    }
+    if (options.stopLabels?.length) {
+        const stop = findLabeledValue(text, options.stopLabels, true, match.valueStart, true);
+        if (stop !== null && stop.labelStart < valueEnd)
+            valueEnd = stop.labelStart;
+    }
+    const value = text.slice(match.valueStart, valueEnd).trim();
+    return value || undefined;
+}
+export function readLabeledEmailUsername(text, labels) {
+    const match = findLabeledValue(text, labels, false);
+    if (match === null || !isEmailLocalCharacter(text[match.valueStart]))
+        return undefined;
+    let end = match.valueStart;
+    while (end < text.length && isEmailLocalCharacter(text[end]))
+        end += 1;
+    return text.slice(match.valueStart, end);
+}
+function isValidDomain(domain) {
+    let labelStart = 0;
+    let dotCount = 0;
+    for (let index = 0; index <= domain.length; index += 1) {
+        if (index < domain.length && domain[index] !== '.') {
+            if (!isAsciiAlphanumeric(domain[index]) && domain[index] !== '-')
+                return false;
+            continue;
+        }
+        if (index === labelStart ||
+            !isAsciiAlphanumeric(domain[labelStart]) ||
+            !isAsciiAlphanumeric(domain[index - 1])) {
+            return false;
+        }
+        if (index < domain.length) {
+            dotCount += 1;
+            labelStart = index + 1;
+        }
+    }
+    if (dotCount < 1 || domain.length - labelStart < 2)
+        return false;
+    for (let index = labelStart; index < domain.length; index += 1) {
+        if (!isAsciiLetter(domain[index]))
+            return false;
+    }
+    return true;
+}
+function isValidEmailParts(local, domain) {
+    if (!local || local.startsWith('.') || local.endsWith('.') || local.includes('..') || !domain) {
+        return false;
+    }
+    return isValidDomain(domain);
+}
+function readEmailAt(text, start) {
+    if (!isEmailLocalCharacter(text[start]))
+        return { nextIndex: start + 1 };
+    let cursor = start;
+    while (cursor < text.length && isEmailLocalCharacter(text[cursor]))
+        cursor += 1;
+    const localEnd = cursor;
+    if (text[cursor] !== '@')
+        return { nextIndex: cursor };
+    cursor += 1;
+    const domainStart = cursor;
+    while (cursor < text.length && isEmailDomainCharacter(text[cursor]))
+        cursor += 1;
+    let addressEnd = cursor;
+    while (addressEnd > domainStart && text[addressEnd - 1] === '.')
+        addressEnd -= 1;
+    const local = text.slice(start, localEnd);
+    const domain = text.slice(domainStart, addressEnd);
+    return {
+        email: isValidEmailParts(local, domain) ? text.slice(start, addressEnd) : undefined,
+        nextIndex: Math.max(cursor, start + 1),
+    };
+}
+export function extractEmailAddresses(text) {
+    const emails = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        if (!isEmailLocalCharacter(text[cursor])) {
+            cursor += 1;
+            continue;
+        }
+        const result = readEmailAt(text, cursor);
+        if (result.email)
+            emails.push(result.email);
+        cursor = result.nextIndex;
+    }
+    return emails;
+}
+export function readLabeledEmail(text, labels) {
+    const match = findLabeledValue(text, labels, true);
+    if (match === null)
+        return undefined;
+    return readEmailAt(text, match.valueStart).email;
+}
+export function extractFencedBlock(text, optionalLanguages) {
+    const openingFence = text.indexOf('```');
+    if (openingFence < 0)
+        return undefined;
+    let contentStart = openingFence + 3;
+    for (const language of optionalLanguages) {
+        if (matchesAsciiCaseInsensitive(text, language, contentStart)) {
+            contentStart += language.length;
+            break;
+        }
+    }
+    contentStart = skipWhitespace(text, contentStart);
+    const closingFence = text.indexOf('```', contentStart);
+    return closingFence < 0 ? undefined : text.slice(contentStart, closingFence);
+}
+export function parseCompactQuantity(text) {
+    let cursor = 0;
+    while (cursor < text.length) {
+        if (!isAsciiDigit(text[cursor])) {
+            cursor += 1;
+            continue;
+        }
+        const numberStart = cursor;
+        while (cursor < text.length && isAsciiDigit(text[cursor]))
+            cursor += 1;
+        if (text[cursor] === '.' && isAsciiDigit(text[cursor + 1])) {
+            cursor += 1;
+            while (cursor < text.length && isAsciiDigit(text[cursor]))
+                cursor += 1;
+        }
+        const numberEnd = cursor;
+        const suffixIndex = skipWhitespace(text, cursor);
+        const suffix = text[suffixIndex]?.toLowerCase();
+        if (suffix === 'k' || suffix === 'm') {
+            const value = Number(text.slice(numberStart, numberEnd));
+            if (Number.isFinite(value))
+                return { value, suffix };
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@agentdomain/eliza-plugin",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "ElizaOS plugin for AgentDomain - give your Eliza agent a complete identity stack",
   "license": "Apache-2.0",
   "repository": "https://github.com/0xmdrakib/AgentDomain.git",
-  "homepage": "https://agentdomain.app/docs",
+  "homepage": "https://docs.agentdomain.app",
   "bugs": "https://github.com/0xmdrakib/AgentDomain/issues",
   "type": "module",
   "main": "./dist/index.js",