a2acalling 0.6.1 → 0.6.3

package/src/lib/config.js

@@ -15,9 +15,165 @@ const CONFIG_DIR = process.env.A2A_CONFIG_DIR ||
 const CONFIG_FILE = path.join(CONFIG_DIR, 'a2a-config.json');
 const logger = createLogger({ component: 'a2a.config' });
 
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function configValidationError(code, message, hint, data) {
+  const err = new Error(message);
+  err.code = code;
+  if (hint) err.hint = hint;
+  if (data) err.data = data;
+  return err;
+}
+
+function sanitizeString(value, maxLength = 200) {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, maxLength);
+}
+
+function validateStringArray(value, label, options = {}) {
+  const maxItems = Number.isFinite(options.maxItems) ? options.maxItems : 200;
+  const itemMaxLength = Number.isFinite(options.itemMaxLength) ? options.itemMaxLength : 160;
+
+  if (!Array.isArray(value)) {
+    throw configValidationError(
+      'A2A_CONFIG_INVALID_ARRAY',
+      `Invalid ${label}: expected an array of strings`,
+      'Pass an array like ["chat","search"].',
+      { label, received_type: typeof value }
+    );
+  }
+
+  const unique = [];
+  const seen = new Set();
+  for (const entry of value) {
+    if (typeof entry !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_ARRAY_ITEM',
+        `Invalid ${label}: each item must be a string`,
+        'Ensure your tier topics/goals are string arrays.',
+        { label, received_item_type: typeof entry }
+      );
+    }
+    const cleaned = sanitizeString(entry, itemMaxLength);
+    if (!cleaned) continue;
+    const key = cleaned.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(cleaned);
+    if (unique.length >= maxItems) break;
+  }
+
+  return unique;
+}
+
+function validateTierPatch(tierName, tierConfig) {
+  if (!isPlainObject(tierConfig)) {
+    throw configValidationError(
+      'A2A_CONFIG_INVALID_TIER_PATCH',
+      `Invalid tier config for "${tierName}": expected an object`,
+      'Pass an object like { topics: [...], goals: [...] }.',
+      { tier: tierName, received_type: typeof tierConfig }
+    );
+  }
+
+  const out = {};
+
+  if (tierConfig.name !== undefined) {
+    if (typeof tierConfig.name !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_NAME',
+        `Invalid tier name for "${tierName}": expected string`,
+        null,
+        { tier: tierName, received_type: typeof tierConfig.name }
+      );
+    }
+    out.name = sanitizeString(tierConfig.name, 120);
+  }
+
+  if (tierConfig.description !== undefined) {
+    if (typeof tierConfig.description !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_DESCRIPTION',
+        `Invalid tier description for "${tierName}": expected string`,
+        null,
+        { tier: tierName, received_type: typeof tierConfig.description }
+      );
+    }
+    out.description = sanitizeString(tierConfig.description, 300);
+  }
+
+  if (tierConfig.disclosure !== undefined) {
+    if (typeof tierConfig.disclosure !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_DISCLOSURE',
+        `Invalid tier disclosure for "${tierName}": expected string`,
+        null,
+        { tier: tierName, received_type: typeof tierConfig.disclosure }
+      );
+    }
+    out.disclosure = sanitizeString(tierConfig.disclosure, 40) || 'minimal';
+  }
+
+  if (tierConfig.capabilities !== undefined) {
+    out.capabilities = validateStringArray(tierConfig.capabilities, `${tierName}.capabilities`, {
+      maxItems: 100,
+      itemMaxLength: 120
+    });
+  }
+
+  if (tierConfig.topics !== undefined) {
+    out.topics = validateStringArray(tierConfig.topics, `${tierName}.topics`, {
+      maxItems: 200,
+      itemMaxLength: 160
+    });
+  }
+
+  if (tierConfig.goals !== undefined) {
+    out.goals = validateStringArray(tierConfig.goals, `${tierName}.goals`, {
+      maxItems: 200,
+      itemMaxLength: 160
+    });
+  }
+
+  if (tierConfig.examples !== undefined) {
+    out.examples = validateStringArray(tierConfig.examples, `${tierName}.examples`, {
+      maxItems: 20,
+      itemMaxLength: 120
+    });
+  }
+
+  return out;
+}
+
+function deepMerge(base, override) {
+  const baseIsObject = base && typeof base === 'object' && !Array.isArray(base);
+  const overrideIsObject = override && typeof override === 'object' && !Array.isArray(override);
+  if (!overrideIsObject) {
+    return override === undefined ? base : override;
+  }
+  const out = baseIsObject ? { ...base } : {};
+  for (const [key, value] of Object.entries(override)) {
+    const baseValue = baseIsObject ? base[key] : undefined;
+    const bothObjects = baseValue && typeof baseValue === 'object' && !Array.isArray(baseValue) &&
+      value && typeof value === 'object' && !Array.isArray(value);
+    out[key] = bothObjects ? deepMerge(baseValue, value) : value;
+  }
+  return out;
+}
+
 const DEFAULT_CONFIG = {
-  // Has the user completed onboarding?
-  onboardingComplete: false,
+  onboarding: {
+    version: 2,
+    step: 'not_started', // not_started|tiers|ingress|verify|complete
+    tiers_confirmed: false,
+    ingress_confirmed: false,
+    verify_confirmed: false,
+    last_run_at: null
+  },
   
   // Permission tiers
   tiers: {
@@ -25,7 +181,7 @@ const DEFAULT_CONFIG = {
       name: 'Public',
       description: 'Basic networking - safe for anyone',
       capabilities: ['context-read'],
-      topics: [],
+      topics: ['chat'],
       goals: [],
       disclosure: 'minimal',
       examples: ['calendar availability', 'public social posts', 'general questions']
@@ -34,19 +190,19 @@ const DEFAULT_CONFIG = {
       name: 'Friends',
       description: 'Most capabilities, no sensitive financial data',
       capabilities: ['context-read', 'calendar.read', 'email.read', 'search'],
-      topics: [],
+      topics: ['chat', 'search', 'openclaw', 'a2a'],
       goals: [],
       disclosure: 'public',
       examples: ['email summaries', 'schedule meetings', 'project discussions']
     },
-    private: {
-      name: 'Private',
-      description: 'Full access - only for you',
+    family: {
+      name: 'Family',
+      description: 'Full access - only for your inner circle',
       capabilities: ['context-read', 'calendar', 'email', 'search', 'tools', 'memory'],
-      topics: [],
+      topics: ['chat', 'search', 'openclaw', 'a2a', 'tools', 'memory'],
       goals: [],
       disclosure: 'public',
-      examples: ['financial data', 'personal notes', 'private conversations']
+      examples: ['deep collaboration', 'private project context', 'personal notes']
     },
     custom: {
       name: 'Custom',
@@ -99,7 +255,7 @@ class A2AConfig {
     if (fs.existsSync(CONFIG_FILE)) {
       try {
         const saved = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
-        return { ...DEFAULT_CONFIG, ...saved };
+        return deepMerge(JSON.parse(JSON.stringify(DEFAULT_CONFIG)), saved);
       } catch (e) {
         logger.error('A2A config is corrupted, using defaults', {
           event: 'a2a_config_corrupt',
@@ -110,10 +266,10 @@ class A2AConfig {
             config_file: CONFIG_FILE
           }
         });
-        return { ...DEFAULT_CONFIG };
+        return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
       }
     }
-    return { ...DEFAULT_CONFIG };
+    return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
   }
 
   _save() {
@@ -133,18 +289,48 @@ class A2AConfig {
 
   // Check if onboarding is complete
   isOnboarded() {
-    return this.config.onboardingComplete === true;
+    return this.config.onboarding &&
+      this.config.onboarding.version === 2 &&
+      this.config.onboarding.step === 'complete';
   }
 
   // Mark onboarding complete
   completeOnboarding() {
-    this.config.onboardingComplete = true;
+    this.config.onboarding = this.config.onboarding || {};
+    this.config.onboarding.version = 2;
+    this.config.onboarding.step = 'complete';
+    this.config.onboarding.tiers_confirmed = true;
+    this.config.onboarding.ingress_confirmed = true;
+    this.config.onboarding.verify_confirmed = true;
+    this.config.onboarding.last_run_at = new Date().toISOString();
     this._save();
   }
 
   // Reset to run onboarding again
   resetOnboarding() {
-    this.config.onboardingComplete = false;
+    this.config.onboarding = this.config.onboarding || {};
+    this.config.onboarding.version = 2;
+    this.config.onboarding.step = 'not_started';
+    this.config.onboarding.tiers_confirmed = false;
+    this.config.onboarding.ingress_confirmed = false;
+    this.config.onboarding.verify_confirmed = false;
+    this.config.onboarding.last_run_at = new Date().toISOString();
+    this._save();
+  }
+
+  getOnboarding() {
+    const ob = (this.config && this.config.onboarding && typeof this.config.onboarding === 'object')
+      ? this.config.onboarding
+      : {};
+    return deepMerge(DEFAULT_CONFIG.onboarding, ob);
+  }
+
+  setOnboarding(patch = {}) {
+    const current = this.getOnboarding();
+    const merged = deepMerge(current, patch);
+    merged.version = 2;
+    merged.last_run_at = new Date().toISOString();
+    this.config.onboarding = merged;
     this._save();
   }
 
@@ -154,7 +340,19 @@ class A2AConfig {
   }
 
   setTier(tierName, tierConfig) {
-    this.config.tiers[tierName] = { ...this.config.tiers[tierName], ...tierConfig };
+    const id = String(tierName || '').trim();
+    if (!id) {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_ID',
+        'Tier name is required',
+        'Use one of: public|friends|family|custom (or a non-empty custom tier id).'
+      );
+    }
+
+    const patch = validateTierPatch(id, tierConfig);
+    this.config.tiers = isPlainObject(this.config.tiers) ? this.config.tiers : {};
+    const existing = isPlainObject(this.config.tiers[id]) ? this.config.tiers[id] : {};
+    this.config.tiers[id] = { ...existing, ...patch };
     this._save();
   }
 

package/src/lib/conversations.js

@@ -47,6 +47,7 @@ class ConversationStore {
         // Best effort - ignore on platforms without chmod support.
       }
       this._migrate();
+      this._ensureLatestSchema(Database);
       return this.db;
     } catch (err) {
       if (err.code === 'MODULE_NOT_FOUND') {
@@ -128,6 +129,79 @@ class ConversationStore {
     `);
   }
 
+  _ensureLatestSchema(Database) {
+    // Prototype-mode stance: do not attempt in-place migrations.
+    // If schema is missing required columns, back up and recreate the DB.
+    try {
+      const info = this.db.prepare('PRAGMA table_info(conversations)').all();
+      if (!Array.isArray(info) || info.length === 0) {
+        return;
+      }
+      const cols = new Set(info.map(row => row && row.name).filter(Boolean));
+      const required = [
+        'joint_action_items',
+        'collaboration_opportunity'
+      ];
+      const missing = required.filter(c => !cols.has(c));
+      if (missing.length === 0) {
+        return;
+      }
+
+      const backupPath = `${this.dbPath}.bak.${Date.now()}`;
+      logger.warn('Conversation DB schema mismatch; resetting to latest schema', {
+        event: 'conversation_db_schema_reset',
+        data: {
+          db_path: this.dbPath,
+          backup_path: backupPath,
+          missing_columns: missing
+        }
+      });
+
+      try { this.db.close(); } catch (_) {}
+      this.db = null;
+
+      try {
+        fs.renameSync(this.dbPath, backupPath);
+      } catch (err) {
+        try {
+          fs.copyFileSync(this.dbPath, backupPath);
+          fs.unlinkSync(this.dbPath);
+        } catch (err2) {
+          // If we can't move the old DB out of the way, keep going without resetting.
+          logger.error('Failed to back up conversations DB for schema reset', {
+            event: 'conversation_db_schema_reset_backup_failed',
+            error: err2,
+            error_code: 'CONVERSATION_DB_SCHEMA_RESET_BACKUP_FAILED',
+            hint: 'Check file permissions on a2a-conversations.db and ensure the process can rename/unlink it.',
+            data: {
+              db_path: this.dbPath,
+              backup_path: backupPath
+            }
+          });
+          const reopen = new Database(this.dbPath);
+          this.db = reopen;
+          return;
+        }
+      }
+
+      this.db = new Database(this.dbPath);
+      try {
+        fs.chmodSync(this.dbPath, 0o600);
+      } catch (err) {
+        // Best effort.
+      }
+      this._migrate();
+    } catch (err) {
+      // Best effort: leave existing DB in place if schema validation fails unexpectedly.
+      logger.error('Conversation DB schema validation failed', {
+        event: 'conversation_db_schema_validation_failed',
+        error: err,
+        error_code: 'CONVERSATION_DB_SCHEMA_VALIDATION_FAILED',
+        hint: 'If this persists, delete ~/.config/openclaw/a2a-conversations.db (prototype mode) and restart.'
+      });
+    }
+  }
+
   /**
    * Generate a conversation ID (shared between both agents)
    */

package/src/lib/disclosure.js

@@ -146,7 +146,7 @@ function generateDefaultManifest(contextFiles = {}) {
   const soulContent = contextFiles.soul || '';
 
   const hasContent = userContent || heartbeatContent || soulContent ||
-    contextFiles.skill || contextFiles.memory || contextFiles.skills || contextFiles.claude;
+    contextFiles.memory || contextFiles.claude;
 
   if (!hasContent) {
     // Minimal starter manifest
@@ -263,21 +263,6 @@ function generateDefaultManifest(contextFiles = {}) {
     }
   }
 
-  // Extract capability keywords from SKILL.md and installed skills
-  const skillContent = (contextFiles.skill || '') + '\n' + (contextFiles.skills || '');
-  if (skillContent.trim()) {
-    const capabilityLines = skillContent
-      .split('\n')
-      .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
-      .map(l => l.replace(/^[\s\-\*]+/, '').trim())
-      .filter(l => l.length > 5 && l.length < 120)
-      .slice(0, 6);
-
-    capabilityLines.forEach(cap => {
-      manifest.topics.public.discuss_freely.push({ topic: cap.slice(0, 60), detail: cap });
-    });
-  }
-
   // Extract topic keywords from memory files
   if (contextFiles.memory) {
     const memoryLines = contextFiles.memory
@@ -350,7 +335,8 @@ function readContextFiles(workspaceDir) {
     heartbeat: read('HEARTBEAT.md'),
     soul: read('SOUL.md'),
     skill: read('SKILL.md'),
-    claude: read('CLAUDE.md')
+    claude: read('CLAUDE.md'),
+    skills: ''
   };
 
   // Scan memory/*.md
@@ -366,32 +352,6 @@ function readContextFiles(workspaceDir) {
     } catch (e) {}
   }
 
-  // Scan installed skills from both OpenClaw and standalone paths
-  const homeDir = process.env.HOME || '/tmp';
-  const skillsDirs = [
-    process.env.OPENCLAW_SKILLS || path.join(homeDir, '.openclaw', 'skills'),
-    path.join(CONFIG_DIR, 'skills')
-  ];
-  const skillFragments = [];
-  const seenSkillDirs = new Set();
-  for (const skillsDir of skillsDirs) {
-    if (!fs.existsSync(skillsDir) || seenSkillDirs.has(skillsDir)) continue;
-    seenSkillDirs.add(skillsDir);
-    try {
-      const dirs = fs.readdirSync(skillsDir).filter(d => {
-        try { return fs.statSync(path.join(skillsDir, d)).isDirectory(); }
-        catch (e) { return false; }
-      });
-      for (const d of dirs) {
-        try {
-          const content = fs.readFileSync(path.join(skillsDir, d, 'SKILL.md'), 'utf8');
-          if (content) skillFragments.push(content);
-        } catch (e) {}
-      }
-    } catch (e) {}
-  }
-  result.skills = skillFragments.join('\n---\n');
-
   return result;
 }
 

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() {