a2acalling 0.6.1 → 0.6.2

package/src/lib/external-ip.js

@@ -22,6 +22,7 @@ const CONFIG_DIR = process.env.A2A_CONFIG_DIR ||
 const EXTERNAL_IP_CACHE_FILE = path.join(CONFIG_DIR, 'a2a-external-ip.json');
 
 const DEFAULT_SERVICES = [
+  'https://ifconfig.me/ip',
   'https://api.ipify.org',
   'https://checkip.amazonaws.com/',
   'https://icanhazip.com/'
@@ -113,6 +114,7 @@ async function fetchExternalIp(options = {}) {
     ? options.services
     : DEFAULT_SERVICES;
 
+  const attempts = [];
   let lastError = null;
   for (const serviceUrl of services) {
     try {
@@ -124,14 +126,18 @@ async function fetchExternalIp(options = {}) {
       if (!ip) {
         throw new Error('invalid_ip');
       }
-      return { ip, source: serviceUrl };
+      attempts.push({ service: serviceUrl, ok: true, statusCode: res.statusCode, ip });
+      return { ip, source: serviceUrl, attempts };
     } catch (err) {
       lastError = err;
+      attempts.push({ service: serviceUrl, ok: false, error: err && err.message ? err.message : 'request_failed' });
     }
   }
 
   const msg = lastError ? lastError.message : 'unavailable';
-  throw new Error(`external_ip_unavailable:${msg}`);
+  const failure = new Error(`external_ip_unavailable:${msg}`);
+  failure.attempts = attempts;
+  throw failure;
 }
 
 /**
@@ -168,13 +174,13 @@ async function getExternalIp(options = {}) {
   }
 
   try {
-    const { ip, source } = await fetchExternalIp({
+    const { ip, source, attempts } = await fetchExternalIp({
       timeoutMs: options.timeoutMs,
       services: options.services
     });
     const checkedAt = new Date(nowMs).toISOString();
     atomicWriteJson(cacheFile, { ip, checked_at: checkedAt, source });
-    return { ip, checkedAt, source, fromCache: false, stale: false };
+    return { ip, checkedAt, source, fromCache: false, stale: false, attempts: Array.isArray(attempts) ? attempts : null };
   } catch (err) {
     if (cached && cached.ip) {
       const cachedIp = parseIp(cached.ip);
@@ -184,11 +190,17 @@ async function getExternalIp(options = {}) {
           checkedAt: cached.checked_at || null,
           source: cached.source || 'cache',
           fromCache: true,
-          stale: true
+          stale: true,
+          error: err && err.message ? err.message : 'external_ip_unavailable',
+          attempts: err && Array.isArray(err.attempts) ? err.attempts : null
         };
       }
     }
-    return { ip: null, error: err.message };
+    return {
+      ip: null,
+      error: err && err.message ? err.message : 'external_ip_unavailable',
+      attempts: err && Array.isArray(err.attempts) ? err.attempts : null
+    };
   }
 }
 
@@ -197,4 +209,3 @@ module.exports = {
   fetchExternalIp,
   getExternalIp
 };
-

package/src/lib/invite-host.js

@@ -166,24 +166,23 @@ async function resolveInviteHost(options = {}) {
       options.refreshExternalIp && isPublicIpHostname(parsed.hostname)
     );
 
-  if (!shouldReplaceWithExternalIp) {
-    return {
-      host: candidateHostWithPort,
-      source: candidateSource,
-      originalHost: candidateHostWithPort,
-      warnings
-    };
-  }
-
-  const external = await getExternalIp({
-    ttlMs,
-    timeoutMs: options.externalIpTimeoutMs,
-    services: options.externalIpServices,
-    cacheFile: options.externalIpCacheFile,
-    forceRefresh: Boolean(options.forceRefreshExternalIp)
-  });
-
-  if (external && external.ip) {
+  const alwaysLookupExternalIp = Boolean(options.alwaysLookupExternalIp);
+  const wantsExternalIp = shouldReplaceWithExternalIp || alwaysLookupExternalIp;
+  const warnOnExternalIpFailure = options.warnOnExternalIpFailure !== undefined
+    ? Boolean(options.warnOnExternalIpFailure)
+    : shouldReplaceWithExternalIp;
+
+  const external = wantsExternalIp
+    ? await getExternalIp({
+      ttlMs,
+      timeoutMs: options.externalIpTimeoutMs,
+      services: options.externalIpServices,
+      cacheFile: options.externalIpCacheFile,
+      forceRefresh: Boolean(options.forceRefreshExternalIp)
+    })
+    : null;
+
+  if (shouldReplaceWithExternalIp && external && external.ip) {
     const finalHost = formatHostPort(external.ip, desiredPort);
     if (finalHost !== candidateHostWithPort) {
       warnings.push(
@@ -195,17 +194,21 @@ async function resolveInviteHost(options = {}) {
       source: 'external_ip',
       originalHost: candidateHostWithPort,
       externalIp: external.ip,
+      externalIpInfo: external,
       warnings
     };
   }
 
-  warnings.push(
-    `Invite host "${candidateHostWithPort}" may not be reachable from other machines, and external IP lookup failed. Set A2A_HOSTNAME="your-public-host:port".`
-  );
+  if (wantsExternalIp && (!external || !external.ip) && warnOnExternalIpFailure) {
+    warnings.push(
+      `Invite host "${candidateHostWithPort}" may not be reachable from other machines, and external IP lookup failed. Set A2A_HOSTNAME="your-public-host:port".`
+    );
+  }
   return {
     host: candidateHostWithPort,
     source: candidateSource,
     originalHost: candidateHostWithPort,
+    externalIpInfo: external,
     warnings
   };
 }

package/src/lib/logger.js

@@ -129,7 +129,28 @@ class LogStore {
       } catch (err) {
         // best effort
       }
-      this._migrate();
+      const ok = this._ensureSchema();
+      if (!ok) {
+        // Prototyping mode: do not attempt DB migrations; keep the old file and start fresh.
+        const backupPath = `${this.dbPath}.legacy.${Date.now()}`;
+        try {
+          this.db.close();
+        } catch (err) {
+          // ignore
+        }
+        fs.renameSync(this.dbPath, backupPath);
+        this.db = new Database(this.dbPath);
+        try {
+          fs.chmodSync(this.dbPath, 0o600);
+        } catch (err) {
+          // best effort
+        }
+        const ok2 = this._ensureSchema();
+        if (!ok2) {
+          this._dbError = 'failed_to_initialize_log_db_schema';
+          return null;
+        }
+      }
       this._prepareStatements();
       return this.db;
     } catch (err) {
@@ -138,7 +159,7 @@ class LogStore {
     }
   }
 
-  _migrate() {
+  _ensureSchema() {
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS logs (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -167,18 +188,9 @@ class LogStore {
     `);
 
     const columns = this.db.prepare(`PRAGMA table_info(logs)`).all();
-    const hasErrorCode = columns.some(c => c.name === 'error_code');
-    const hasStatusCode = columns.some(c => c.name === 'status_code');
-    const hasHint = columns.some(c => c.name === 'hint');
-    if (!hasErrorCode) {
-      this.db.exec(`ALTER TABLE logs ADD COLUMN error_code TEXT`);
-    }
-    if (!hasStatusCode) {
-      this.db.exec(`ALTER TABLE logs ADD COLUMN status_code INTEGER`);
-    }
-    if (!hasHint) {
-      this.db.exec(`ALTER TABLE logs ADD COLUMN hint TEXT`);
-    }
+    const names = new Set(columns.map(c => c && c.name).filter(Boolean));
+    const required = ['timestamp', 'level', 'component', 'message', 'error_code', 'status_code', 'hint', 'data'];
+    return required.every((name) => names.has(name));
   }
 
   _prepareStatements() {