a2acalling 0.6.47 → 0.6.49

package/src/lib/update-checker.js

@@ -0,0 +1,93 @@
+/**
+ * Update Checker
+ *
+ * Zero-dependency npm version checks for a2acalling.
+ */
+
+const REGISTRY_URL = 'https://registry.npmjs.org/a2acalling/latest';
+const FETCH_TIMEOUT_MS = 15000;
+
+function parseVersion(str) {
+  if (!str || typeof str !== 'string') return null;
+  const match = str.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10)
+  };
+}
+
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return 0;
+  if (va.major !== vb.major) return va.major < vb.major ? -1 : 1;
+  if (va.minor !== vb.minor) return va.minor < vb.minor ? -1 : 1;
+  if (va.patch !== vb.patch) return va.patch < vb.patch ? -1 : 1;
+  return 0;
+}
+
+function isSameMajor(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return false;
+  return va.major === vb.major;
+}
+
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: 'application/json' }
+    });
+    clearTimeout(timeout);
+    if (!res.ok) {
+      return { error: `Registry returned ${res.status}` };
+    }
+    const data = await res.json();
+    if (!data || typeof data.version !== 'string') {
+      return { error: 'No version field in registry response' };
+    }
+    return { version: data.version };
+  } catch (err) {
+    if (err && err.name === 'AbortError') {
+      return { error: 'Registry request timed out' };
+    }
+    return { error: err && err.message ? err.message : 'Unknown fetch error' };
+  }
+}
+
+async function checkForUpdate(currentVersion) {
+  const result = await fetchLatestVersion();
+  if (result.error) {
+    return {
+      available: false,
+      current: currentVersion,
+      latest: null,
+      sameMajor: false,
+      error: result.error
+    };
+  }
+
+  const latest = result.version;
+  return {
+    available: compareVersions(currentVersion, latest) < 0,
+    current: currentVersion,
+    latest,
+    sameMajor: isSameMajor(currentVersion, latest)
+  };
+}
+
+module.exports = {
+  REGISTRY_URL,
+  FETCH_TIMEOUT_MS,
+  parseVersion,
+  compareVersions,
+  isSameMajor,
+  fetchLatestVersion,
+  checkForUpdate
+};
+

package/src/lib/update-manager.js

@@ -0,0 +1,313 @@
+const { execFile } = require('child_process');
+const { EventEmitter } = require('events');
+const { createLogger } = require('./logger');
+const { checkForUpdate, isSameMajor } = require('./update-checker');
+
+const DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
+const DEFAULT_NPM_TIMEOUT_MS = 2 * 60 * 1000;
+
+function isUpdateSafe(callMonitor) {
+  if (!callMonitor || typeof callMonitor.getActiveCount !== 'function') return true;
+  return Number(callMonitor.getActiveCount()) === 0;
+}
+
+function shouldApplyUpdate(currentVersion, latestVersion, options = {}) {
+  if (!latestVersion) return false;
+  if (options.allowMajor) return true;
+  return isSameMajor(currentVersion, latestVersion);
+}
+
+function autoUpdateDisabledByEnv() {
+  if (String(process.env.CI || '').toLowerCase() === 'true') return true;
+  if (String(process.env.A2A_AUTO_UPDATE || '').trim() === '0') return true;
+  if (String(process.env.NO_AUTO_UPDATE || '').trim() === '1') return true;
+  return false;
+}
+
+function execFilePromise(cmd, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, options, (err, stdout, stderr) => {
+      if (err) {
+        err.stdout = stdout;
+        err.stderr = stderr;
+        reject(err);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+class UpdateManager extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.currentVersion = options.currentVersion;
+    this.config = options.config || null;
+    this.logger = options.logger || createLogger({ component: 'a2a.updater' });
+    this.intervalMs = Number.isFinite(options.intervalMs) && options.intervalMs > 0
+      ? options.intervalMs
+      : DEFAULT_INTERVAL_MS;
+    this.allowMajor = Boolean(options.allowMajor);
+    this.enabled = options.enabled !== false;
+    this.getCallMonitor = typeof options.getCallMonitor === 'function'
+      ? options.getCallMonitor
+      : (() => null);
+    this.installTimeoutMs = Number.isFinite(options.installTimeoutMs) && options.installTimeoutMs > 0
+      ? options.installTimeoutMs
+      : DEFAULT_NPM_TIMEOUT_MS;
+    this.restartFn = typeof options.restartFn === 'function' ? options.restartFn : null;
+    this._execFile = options.execFile || execFilePromise;
+    this._status = {
+      state: 'up_to_date',
+      enabled: this.enabled,
+      current_version: this.currentVersion,
+      latest_version: this.currentVersion,
+      target_version: null,
+      active_calls: 0,
+      last_checked_at: null,
+      last_success_at: null,
+      last_error: null,
+      defer_reason: null
+    };
+    this._timer = null;
+    this._running = false;
+    this._pendingManualUpdate = false;
+
+    this._loadConfig();
+    if (autoUpdateDisabledByEnv()) {
+      this.enabled = false;
+      this._status.enabled = false;
+      this.logger.info('Auto-update disabled by environment', { event: 'updater_env_disabled' });
+    }
+  }
+
+  _loadConfig() {
+    if (!this.config || typeof this.config.getAutoUpdate !== 'function') return;
+    const cfg = this.config.getAutoUpdate();
+    if (cfg && typeof cfg === 'object') {
+      if (typeof cfg.enabled === 'boolean') this.enabled = cfg.enabled;
+      if (Number.isFinite(cfg.intervalMs) && cfg.intervalMs > 0) this.intervalMs = cfg.intervalMs;
+      if (typeof cfg.allowMajor === 'boolean') this.allowMajor = cfg.allowMajor;
+    }
+    this._status.enabled = this.enabled;
+  }
+
+  _persistConfigPatch(patch) {
+    if (!this.config || typeof this.config.setAutoUpdate !== 'function') return;
+    try {
+      this.config.setAutoUpdate(patch);
+    } catch (err) {
+      this.logger.warn('Failed to persist auto-update config patch', {
+        event: 'updater_config_patch_failed',
+        error: err
+      });
+    }
+  }
+
+  _setStatus(patch) {
+    this._status = { ...this._status, ...patch };
+    this.emit('status', this.getStatus());
+  }
+
+  getStatus() {
+    return {
+      ...this._status,
+      enabled: this.enabled,
+      interval_ms: this.intervalMs,
+      allow_major: this.allowMajor
+    };
+  }
+
+  async setEnabled(enabled) {
+    this.enabled = Boolean(enabled);
+    this._setStatus({ enabled: this.enabled });
+    this._persistConfigPatch({ enabled: this.enabled });
+    if (this.enabled && !this._timer) {
+      this.start();
+      await this.triggerCheck({ reason: 'manual_enable' });
+    }
+    if (!this.enabled && this._timer) {
+      this.stop();
+    }
+    return this.getStatus();
+  }
+
+  start() {
+    if (this._timer) return;
+    if (!this.enabled) {
+      this.logger.info('Auto-updater disabled', { event: 'updater_disabled' });
+      return;
+    }
+
+    this._timer = setInterval(() => {
+      this.triggerCheck({ reason: 'interval' }).catch((err) => {
+        this.logger.warn('Auto-update interval check failed', {
+          event: 'updater_interval_failed',
+          error: err
+        });
+      });
+    }, this.intervalMs);
+
+    this.logger.info('Auto-updater started', {
+      event: 'updater_started',
+      data: {
+        interval_ms: this.intervalMs,
+        allow_major: this.allowMajor
+      }
+    });
+  }
+
+  stop() {
+    if (!this._timer) return;
+    clearInterval(this._timer);
+    this._timer = null;
+    this.logger.info('Auto-updater stopped', { event: 'updater_stopped' });
+  }
+
+  async triggerCheck(options = {}) {
+    return this._runCycle({ ...options, manualUpdate: false, forceCheck: Boolean(options.forceCheck) });
+  }
+
+  async triggerUpdate(options = {}) {
+    this._pendingManualUpdate = true;
+    return this._runCycle({ ...options, manualUpdate: true });
+  }
+
+  async _runCycle(options = {}) {
+    if (this._running) {
+      return this.getStatus();
+    }
+    if (!this.enabled && !options.manualUpdate && !options.forceCheck) {
+      return this.getStatus();
+    }
+
+    this._running = true;
+    const nowIso = new Date().toISOString();
+    this._setStatus({
+      state: 'checking',
+      last_checked_at: nowIso,
+      last_error: null,
+      defer_reason: null
+    });
+
+    try {
+      const result = await checkForUpdate(this.currentVersion);
+      if (result.error) {
+        this._setStatus({
+          state: 'failed',
+          latest_version: this.currentVersion,
+          last_error: result.error
+        });
+        return this.getStatus();
+      }
+
+      const latest = result.latest || this.currentVersion;
+      if (!result.available) {
+        this._setStatus({
+          state: 'up_to_date',
+          latest_version: latest,
+          target_version: null
+        });
+        return this.getStatus();
+      }
+
+      if (!shouldApplyUpdate(this.currentVersion, latest, { allowMajor: this.allowMajor })) {
+        this._setStatus({
+          state: 'up_to_date',
+          latest_version: latest,
+          target_version: null,
+          defer_reason: 'cross_major_blocked'
+        });
+        return this.getStatus();
+      }
+
+      const monitor = this.getCallMonitor();
+      const activeCalls = monitor && typeof monitor.getActiveCount === 'function'
+        ? Number(monitor.getActiveCount()) || 0
+        : 0;
+      if (!isUpdateSafe(monitor) && !options.force) {
+        this._setStatus({
+          state: 'waiting_for_safe_restart',
+          latest_version: latest,
+          target_version: latest,
+          active_calls: activeCalls,
+          defer_reason: 'active_calls'
+        });
+        return this.getStatus();
+      }
+
+      this._setStatus({
+        state: 'downloading',
+        latest_version: latest,
+        target_version: latest,
+        active_calls: activeCalls
+      });
+
+      await this._installVersion(latest);
+      this.currentVersion = latest;
+      this._persistConfigPatch({ lastGoodVersion: latest });
+
+      this._setStatus({
+        state: 'restarting',
+        current_version: latest,
+        latest_version: latest,
+        target_version: latest,
+        last_success_at: new Date().toISOString(),
+        last_error: null,
+        defer_reason: null,
+        active_calls: 0
+      });
+
+      if (this.restartFn) {
+        await this.restartFn(latest);
+      } else {
+        this._setStatus({
+          state: 'up_to_date',
+          current_version: latest,
+          latest_version: latest,
+          target_version: null
+        });
+      }
+
+      return this.getStatus();
+    } catch (err) {
+      const message = err && err.message ? err.message : 'update_failed';
+      this._setStatus({
+        state: 'failed',
+        last_error: message
+      });
+      this.logger.error('Auto-update failed', {
+        event: 'updater_failed',
+        error: err
+      });
+      return this.getStatus();
+    } finally {
+      this._running = false;
+      this._pendingManualUpdate = false;
+    }
+  }
+
+  async _installVersion(version) {
+    const args = ['install', '-g', `a2acalling@${version}`];
+    this._setStatus({ state: 'applying' });
+    this.logger.info('Installing auto-update target', {
+      event: 'updater_install_start',
+      data: { version }
+    });
+    await this._execFile('npm', args, {
+      timeout: this.installTimeoutMs,
+      env: process.env
+    });
+    this.logger.info('Auto-update install complete', {
+      event: 'updater_install_done',
+      data: { version }
+    });
+  }
+}
+
+module.exports = {
+  DEFAULT_INTERVAL_MS,
+  isUpdateSafe,
+  shouldApplyUpdate,
+  UpdateManager
+};

package/src/routes/a2a.js

@@ -174,17 +174,24 @@ function createRoutes(options = {}) {
     maxDurationMs: options.maxDurationMs || 300000,
     logger: logger.child({ component: 'a2a.call-monitor' })
   });
+  if (typeof options.onCallMonitor === 'function') {
+    try {
+      options.onCallMonitor(monitor);
+    } catch (_) {}
+  }
 
   /**
    * GET /status
    * Check if A2A is enabled
    */
   router.get('/status', (req, res) => {
+    const activeCalls = monitor ? monitor.getActiveCount() : 0;
     res.json({
       a2a: true,
       version: require('../../package.json').version,
       capabilities: ['invoke', 'multi-turn'],
-      rate_limits: limits
+      rate_limits: limits,
+      active_calls: activeCalls
     });
   });
 

package/src/routes/dashboard.js

@@ -210,12 +210,45 @@ function buildContext(options = {}) {
     config,
     convStore,
     callbookStore,
+    getUpdateManager: typeof options.getUpdateManager === 'function'
+      ? options.getUpdateManager
+      : (() => null),
     logger,
     agentContext,
     staticDir: DASHBOARD_STATIC_DIR
   };
 }
 
+function resolveAutoUpdateStatus(context) {
+  const manager = context.getUpdateManager ? context.getUpdateManager() : null;
+  const config = context.config && typeof context.config.getAutoUpdate === 'function'
+    ? context.config.getAutoUpdate()
+    : {
+      enabled: true,
+      intervalMs: 60 * 60 * 1000,
+      allowMajor: false,
+      lastGoodVersion: null
+    };
+  const runtime = manager && typeof manager.getStatus === 'function'
+    ? manager.getStatus()
+    : null;
+  return {
+    enabled: runtime ? Boolean(runtime.enabled) : Boolean(config.enabled),
+    interval_ms: runtime && Number.isFinite(runtime.interval_ms) ? runtime.interval_ms : config.intervalMs,
+    allow_major: runtime ? Boolean(runtime.allow_major) : Boolean(config.allowMajor),
+    state: runtime ? runtime.state : 'up_to_date',
+    current_version: runtime ? runtime.current_version : require('../../package.json').version,
+    latest_version: runtime ? runtime.latest_version : null,
+    target_version: runtime ? runtime.target_version : null,
+    active_calls: runtime ? runtime.active_calls : 0,
+    last_checked_at: runtime ? runtime.last_checked_at : null,
+    last_success_at: runtime ? runtime.last_success_at : null,
+    last_error: runtime ? runtime.last_error : null,
+    defer_reason: runtime ? runtime.defer_reason : null,
+    last_good_version: config.lastGoodVersion || null
+  };
+}
+
 function buildContactIndex(contacts) {
   const byName = new Map();
   const byId = new Map();
@@ -537,7 +570,76 @@ function createDashboardApiRouter(options = {}) {
       callbook: {
         enabled: Boolean(context.callbookStore && context.callbookStore.isAvailable()),
         device_count: Array.isArray(devices) ? devices.length : 0
-      }
+      },
+      auto_update: resolveAutoUpdateStatus(context)
+    });
+  });
+
+  router.get('/update/status', (req, res) => {
+    return res.json({
+      success: true,
+      auto_update: resolveAutoUpdateStatus(context)
+    });
+  });
+
+  router.post('/update/check', async (req, res) => {
+    const manager = context.getUpdateManager ? context.getUpdateManager() : null;
+    if (!manager || typeof manager.triggerCheck !== 'function') {
+      return res.status(503).json({
+        success: false,
+        error: 'updater_unavailable',
+        message: 'Auto-updater is not initialized for this server.'
+      });
+    }
+    await manager.triggerCheck({ reason: 'dashboard_manual_check', forceCheck: true });
+    return res.json({
+      success: true,
+      auto_update: resolveAutoUpdateStatus(context)
+    });
+  });
+
+  router.post('/update/now', async (req, res) => {
+    const manager = context.getUpdateManager ? context.getUpdateManager() : null;
+    if (!manager || typeof manager.triggerUpdate !== 'function') {
+      return res.status(503).json({
+        success: false,
+        error: 'updater_unavailable',
+        message: 'Auto-updater is not initialized for this server.'
+      });
+    }
+    const force = parseBoolean(req.body && (req.body.force !== undefined ? req.body.force : req.body.force_update));
+    await manager.triggerUpdate({
+      reason: 'dashboard_manual_update',
+      force
+    });
+    return res.json({
+      success: true,
+      auto_update: resolveAutoUpdateStatus(context)
+    });
+  });
+
+  router.put('/update/config', async (req, res) => {
+    const manager = context.getUpdateManager ? context.getUpdateManager() : null;
+    const body = req.body || {};
+    const enabled = body.enabled !== undefined ? parseBoolean(body.enabled) : undefined;
+
+    if (enabled === undefined) {
+      return res.status(400).json({
+        success: false,
+        error: 'enabled_required',
+        message: 'Pass { enabled: true|false }.'
+      });
+    }
+
+    if (manager && typeof manager.setEnabled === 'function') {
+      await manager.setEnabled(enabled);
+    } else if (context.config && typeof context.config.setAutoUpdate === 'function') {
+      context.config.setAutoUpdate({ enabled });
+    }
+
+    return res.json({
+      success: true,
+      auto_update: resolveAutoUpdateStatus(context)
     });
   });