@serve.zone/dcrouter 17.0.0 → 17.1.0

package/ts/dns/manager.dns.ts

@@ -648,7 +648,12 @@ export class DnsManager {
    * Force-resync a provider-managed domain: re-pull all records from the
    * provider API, replacing the cached DnsRecordDocs.
    */
-  public async syncDomain(id: string): Promise<{ success: boolean; recordCount?: number; message?: string }> {
+  public async syncDomain(id: string): Promise<{
+    success: boolean;
+    recordCount?: number;
+    listedProviderRecordIds?: string[];
+    message?: string;
+  }> {
     const doc = await DomainDoc.findById(id);
     if (!doc) return { success: false, message: 'Domain not found' };
     if (doc.source !== 'provider' || !doc.providerId) {
@@ -658,21 +663,39 @@ export class DnsManager {
     if (!client) {
       return { success: false, message: 'Provider client unavailable' };
     }
-    const providerRecords = await client.listRecords(doc.name);
+    let providerRecords: IProviderRecord[];
+    try {
+      providerRecords = await client.listRecords(doc.name);
+    } catch (error: unknown) {
+      return { success: false, message: `Provider list failed: ${(error as Error).message}` };
+    }
+    const providerIds = providerRecords.map((record) => record.providerRecordId.trim());
+    if (providerIds.some((providerId) => !providerId)) {
+      return { success: false, message: 'Provider returned a record without a non-empty provider id' };
+    }
+    if (new Set(providerIds).size !== providerIds.length) {
+      return { success: false, message: 'Provider returned duplicate provider record ids' };
+    }
 
-    // Merge by provider id, then exact tuple. Replacing the collection would
-    // erase explicit ownership metadata from reconciler-managed rows.
+    // Provider ids are the only identity proof. Tuple matching could adopt an
+    // operator replacement and transfer reconciler ownership to the wrong row.
     const existing = await DnsRecordDoc.findByDomainId(id);
+    const localByProviderId = new Map<string, DnsRecordDoc>();
+    for (const record of existing) {
+      const providerId = record.providerRecordId?.trim();
+      if (!providerId) continue;
+      if (localByProviderId.has(providerId)) {
+        return { success: false, message: `Local mirror has duplicate provider record id ${providerId}` };
+      }
+      localByProviderId.set(providerId, record);
+    }
     const remaining = new Set(existing);
-    for (const pr of providerRecords) {
-      const match = existing.find((record) => record.providerRecordId === pr.providerRecordId)
-        || existing.find((record) => (
-          record.name.toLowerCase() === pr.name.toLowerCase()
-          && record.type === pr.type
-          && record.value.trim() === pr.value.trim()
-        ));
+    for (let index = 0; index < providerRecords.length; index++) {
+      const pr = providerRecords[index];
+      const providerId = providerIds[index];
+      const match = localByProviderId.get(providerId);
       if (!match) {
-        await this.createSyncedRecord(id, pr, doc.createdBy);
+        await this.createSyncedRecord(id, { ...pr, providerRecordId: providerId }, doc.createdBy);
         continue;
       }
       remaining.delete(match);
@@ -682,17 +705,22 @@ export class DnsManager {
       match.ttl = pr.ttl;
       match.proxied = pr.proxied;
       match.source = 'synced';
-      match.providerRecordId = pr.providerRecordId;
+      match.providerRecordId = providerId;
       match.updatedAt = Date.now();
       await match.save();
     }
     for (const staleMirror of remaining) {
+      if (staleMirror.source !== 'synced' || !staleMirror.providerRecordId?.trim()) continue;
       await staleMirror.delete();
     }
     doc.lastSyncedAt = Date.now();
     doc.updatedAt = doc.lastSyncedAt;
     await doc.save();
-    return { success: true, recordCount: providerRecords.length };
+    return {
+      success: true,
+      recordCount: providerRecords.length,
+      listedProviderRecordIds: providerIds,
+    };
   }
 
   // ==========================================================================
@@ -900,7 +928,9 @@ export class DnsManager {
           ttl: doc.ttl,
           proxied: doc.proxied,
         });
-        doc.providerRecordId = created.providerRecordId;
+        const providerRecordId = created.providerRecordId.trim();
+        if (!providerRecordId) throw new Error('Provider returned an empty record id');
+        doc.providerRecordId = providerRecordId;
         doc.source = 'synced';
       } catch (err: unknown) {
         return { success: false, message: `Provider rejected record: ${(err as Error).message}` };
@@ -1007,6 +1037,10 @@ export class DnsManager {
     pr: IProviderRecord,
     createdBy: string,
   ): Promise<void> {
+    const providerRecordId = pr.providerRecordId.trim();
+    if (!providerRecordId) {
+      throw new Error('Cannot mirror a provider record without a non-empty provider id');
+    }
     const now = Date.now();
     const doc = new DnsRecordDoc();
     doc.id = plugins.uuid.v4();
@@ -1017,7 +1051,7 @@ export class DnsManager {
     doc.ttl = pr.ttl;
     if (pr.proxied !== undefined) doc.proxied = pr.proxied;
     doc.source = 'synced';
-    doc.providerRecordId = pr.providerRecordId;
+    doc.providerRecordId = providerRecordId;
     doc.createdAt = now;
     doc.updatedAt = now;
     doc.createdBy = createdBy;

package/ts/dns/providers/cloudflare.provider.ts

@@ -8,6 +8,10 @@ import type {
 } from './interfaces.js';
 import type { IProviderDomainListing } from '../../../ts_interfaces/data/dns-provider.js';
 import type { TDnsRecordType } from '../../../ts_interfaces/data/dns-record.js';
+import {
+  decodeTxtRecordContent,
+  encodeCloudflareTxtContent,
+} from '../txt-record-presentation.js';
 
 /**
  * Cloudflare implementation of IDnsProviderClient.
@@ -120,6 +124,9 @@ export class CloudflareDnsProvider implements IDnsProviderClient {
   }
 
   private toApiRecordValue(record: IProviderRecordInput): { content: string; priority?: number } {
+    if (record.type === 'TXT') {
+      return { content: encodeCloudflareTxtContent(record.value) };
+    }
     if (record.type !== 'MX') {
       return { content: record.value };
     }
@@ -135,9 +142,20 @@ export class CloudflareDnsProvider implements IDnsProviderClient {
   }
 
   private fromApiRecord(record: any): IProviderRecord {
-    const value = record.type === 'MX'
-      ? `${Number(record.priority)} ${record.content}`
-      : String(record.content);
+    let value: string;
+    if (record.type === 'MX') {
+      value = `${Number(record.priority)} ${record.content}`;
+    } else if (record.type === 'TXT') {
+      const decoded = decodeTxtRecordContent(String(record.content));
+      if (!decoded.ok) {
+        throw new Error(
+          `CloudflareDnsProvider: malformed TXT content for ${String(record.name)}: ${decoded.error}`,
+        );
+      }
+      value = decoded.value;
+    } else {
+      value = String(record.content);
+    }
     return {
       providerRecordId: String(record.id),
       name: String(record.name),

package/ts/dns/txt-record-presentation.ts

@@ -0,0 +1,134 @@
+export type TTxtContentDecodeResult =
+  | { ok: true; value: string; wasPresentation: boolean }
+  | { ok: false; error: string };
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder('utf-8', { fatal: true });
+
+function appendCharacterBytes(target: number[], character: string): void {
+  target.push(...textEncoder.encode(character));
+}
+
+/**
+ * Decode the representation returned by DNS provider APIs for TXT records.
+ *
+ * Cloudflare uses RFC 1035 presentation syntax (one or more adjacent quoted
+ * character strings). Some older API responses and dcrouter mirrors contain
+ * the already-decoded payload, so an unquoted input is accepted as canonical.
+ * A value that starts as presentation syntax must parse completely; malformed
+ * quoting or escaping is never repaired by stripping quote characters.
+ */
+export function decodeTxtRecordContent(input: string): TTxtContentDecodeResult {
+  const source = input.trim();
+  if (!source.startsWith('"')) {
+    return { ok: true, value: source, wasPresentation: false };
+  }
+
+  const bytes: number[] = [];
+  let index = 0;
+  let chunkCount = 0;
+  while (index < source.length) {
+    while (/\s/.test(source[index] || '')) index++;
+    if (index >= source.length) break;
+    if (source[index] !== '"') {
+      return { ok: false, error: `Unexpected TXT presentation content at offset ${index}` };
+    }
+    chunkCount++;
+    index++;
+    let closed = false;
+    while (index < source.length) {
+      const character = source[index];
+      if (character === '"') {
+        index++;
+        closed = true;
+        break;
+      }
+      if (character === '\\') {
+        index++;
+        if (index >= source.length) {
+          return { ok: false, error: 'TXT presentation ends with an incomplete escape' };
+        }
+        if (/\d/.test(source[index])) {
+          const decimalEscape = source.slice(index, index + 3);
+          if (!/^\d{3}$/.test(decimalEscape)) {
+            return { ok: false, error: `Invalid TXT decimal escape at offset ${index - 1}` };
+          }
+          const byte = Number.parseInt(decimalEscape, 10);
+          if (byte > 255) {
+            return { ok: false, error: `TXT decimal escape exceeds 255 at offset ${index - 1}` };
+          }
+          bytes.push(byte);
+          index += 3;
+          continue;
+        }
+        const escapedCodePoint = source.codePointAt(index);
+        if (escapedCodePoint === undefined) {
+          return { ok: false, error: `Invalid TXT escape at offset ${index - 1}` };
+        }
+        const escapedCharacter = String.fromCodePoint(escapedCodePoint);
+        appendCharacterBytes(bytes, escapedCharacter);
+        index += escapedCharacter.length;
+        continue;
+      }
+      const codePoint = source.codePointAt(index);
+      if (codePoint === undefined) {
+        return { ok: false, error: `Invalid TXT character at offset ${index}` };
+      }
+      const nextCharacter = String.fromCodePoint(codePoint);
+      appendCharacterBytes(bytes, nextCharacter);
+      index += nextCharacter.length;
+    }
+    if (!closed) {
+      return { ok: false, error: 'TXT presentation contains an unterminated character string' };
+    }
+    while (/\s/.test(source[index] || '')) index++;
+    if (index < source.length && source[index] !== '"') {
+      return { ok: false, error: `Unexpected TXT presentation content at offset ${index}` };
+    }
+  }
+
+  if (chunkCount === 0) {
+    return { ok: false, error: 'TXT presentation contains no character strings' };
+  }
+  try {
+    return { ok: true, value: textDecoder.decode(Uint8Array.from(bytes)), wasPresentation: true };
+  } catch {
+    return { ok: false, error: 'TXT presentation is not valid UTF-8' };
+  }
+}
+
+function escapeTxtChunk(chunk: string): string {
+  let result = '';
+  for (const character of chunk) {
+    const codePoint = character.codePointAt(0)!;
+    if (character === '"' || character === '\\') {
+      result += `\\${character}`;
+    } else if (codePoint < 32 || codePoint === 127) {
+      for (const byte of textEncoder.encode(character)) {
+        result += `\\${byte.toString(10).padStart(3, '0')}`;
+      }
+    } else {
+      result += character;
+    }
+  }
+  return result;
+}
+
+/** Encode a canonical TXT payload as Cloudflare/RFC 1035 presentation text. */
+export function encodeCloudflareTxtContent(value: string): string {
+  const chunks: string[] = [];
+  let current = '';
+  let currentBytes = 0;
+  for (const character of value) {
+    const characterBytes = textEncoder.encode(character).length;
+    if (currentBytes > 0 && currentBytes + characterBytes > 255) {
+      chunks.push(current);
+      current = '';
+      currentBytes = 0;
+    }
+    current += character;
+    currentBytes += characterBytes;
+  }
+  chunks.push(current);
+  return chunks.map((chunk) => `"${escapeTxtChunk(chunk)}"`).join(' ');
+}