create-walle 0.9.13 → 0.9.15

package/template/wall-e/api-walle.js

@@ -27,8 +27,8 @@ function getTelemetryDb() {
     const fs = require('fs');
     if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
     telemetryDb = new Database(TELEMETRY_DB_PATH);
-    telemetryDb.pragma('journal_mode = DELETE');
-    telemetryDb.pragma('busy_timeout = 3000');
+    telemetryDb.pragma('journal_mode = WAL');
+    telemetryDb.pragma('busy_timeout = 5000');
     telemetryDb.exec(`
       CREATE TABLE IF NOT EXISTS telemetry_events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -53,12 +53,14 @@ function getTelemetryDb() {
         os TEXT,
         node_version TEXT,
         ip TEXT,
+        machine_bucket TEXT,
         event_count INTEGER DEFAULT 0
       );
     `);
     // Migrate: add ip column if missing
     try { telemetryDb.prepare('ALTER TABLE telemetry_events ADD COLUMN ip TEXT').run(); } catch {}
     try { telemetryDb.prepare('ALTER TABLE telemetry_installs ADD COLUMN ip TEXT').run(); } catch {}
+    try { telemetryDb.prepare('ALTER TABLE telemetry_installs ADD COLUMN machine_bucket TEXT').run(); } catch {}
     return telemetryDb;
   } catch (e) {
     console.error('[wall-e] Failed to init telemetry DB:', e.message);
@@ -158,6 +160,53 @@ function ensureBrainInit() {
   return true;
 }
 
+const SETUP_PROVIDER_TYPES = ['anthropic', 'openai', 'google', 'ollama', 'deepseek'];
+const SETUP_PROVIDER_NAMES = {
+  anthropic: 'Anthropic',
+  openai: 'OpenAI',
+  google: 'Google Gemini',
+  ollama: 'Ollama (Local)',
+  deepseek: 'DeepSeek',
+};
+
+function sanitizeSetupProviderType(value) {
+  const type = String(value || '').toLowerCase().replace(/[^a-z0-9_-]/g, '').slice(0, 32);
+  return SETUP_PROVIDER_TYPES.includes(type) ? type : '';
+}
+
+function sanitizeSetupModel(value) {
+  return typeof value === 'string' ? value.replace(/[\r\n\s]/g, '').slice(0, 100) : '';
+}
+
+function sanitizeTaskType(value) {
+  return typeof value === 'string' ? value.replace(/[^a-z0-9_-]/gi, '').slice(0, 64) : '';
+}
+
+function sanitizeModelRegistryId(value) {
+  return value == null || value === ''
+    ? null
+    : String(value).replace(/[^a-z0-9_:.@/\-]/gi, '').slice(0, 128);
+}
+
+function syncRuntimeDefaultsFromBrain() {
+  if (!brain) return;
+  try {
+    const provider = brain.getKv('walle_provider');
+    const model = brain.getKv('walle_model');
+    if (provider) process.env.WALLE_PROVIDER = provider;
+    if (model) process.env.WALLE_MODEL = model;
+    else delete process.env.WALLE_MODEL;
+    _runtimeDefaultsSynced = true;
+  } catch {}
+}
+
+function resetDefaultClientQuiet() {
+  try {
+    const { resetDefaultClient } = require('./llm/client');
+    resetDefaultClient();
+  } catch {}
+}
+
 // --- Individual route handlers (exported for testability) ---
 
 function getStatus() {
@@ -305,12 +354,48 @@ function handleWalleApi(req, res, url) {
     }
   }
 
+  // POST /api/wall-e/update/prompt-event — anonymous upgrade prompt funnel
+  if (p === '/api/wall-e/update/prompt-event' && m === 'POST') {
+    return readBody(req).then(body => {
+      try {
+        const allowed = new Set(['shown', 'later', 'dismissed', 'copy_command']);
+        const action = allowed.has(body?.action) ? body.action : 'unknown';
+        const updateRaw = brain.getKv('update_available');
+        const update = updateRaw ? JSON.parse(updateRaw) : {};
+        const telemetry = require('./telemetry');
+        telemetry.track('upgrade_prompt', {
+          action,
+          current: update.current || 'unknown',
+          latest: update.latest || 'unknown',
+          source: 'walle_ui',
+        });
+        if (action === 'shown') telemetry.trackFunnelStep('upgrade_prompt_shown');
+        if (action === 'dismissed') telemetry.trackFunnelStep('upgrade_prompt_dismissed');
+        if (action === 'copy_command') telemetry.trackFunnelStep('upgrade_prompt_command_copied');
+        return jsonResponse(res, { ok: true }), true;
+      } catch (e) {
+        return jsonResponse(res, { error: e.message }, 500), true;
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 500));
+  }
+
   // DELETE /api/wall-e/alerts/:id — dismiss an alert
   if (p.startsWith('/api/wall-e/alerts/') && m === 'DELETE') {
     try {
       const alertId = decodeURIComponent(p.split('/api/wall-e/alerts/')[1]);
       if (alertId === 'version_update') {
-        const brain = require('./brain');
+        try {
+          const telemetry = require('./telemetry');
+          const updateRaw = brain.getKv('update_available');
+          const update = updateRaw ? JSON.parse(updateRaw) : {};
+          telemetry.track('upgrade_prompt', {
+            action: 'dismissed',
+            current: update.current || 'unknown',
+            latest: update.latest || 'unknown',
+            source: 'alert_delete',
+          });
+          telemetry.trackFunnelStep('upgrade_prompt_dismissed');
+        } catch {}
         brain.setKv('update_available', '');
       } else {
         const { dismissServiceAlert } = require('./skills/skill-planner');
@@ -362,14 +447,68 @@ function handleWalleApi(req, res, url) {
 
   // GET /api/wall-e/slack/status — check Slack OAuth status
   if (p === '/api/wall-e/slack/status' && m === 'GET') {
+    (async () => {
+      try {
+        const slackMcp = require('./tools/slack-mcp');
+        const { getSlackOwnerRepairState } = require('./tools/slack-owner');
+        const { clearResolvedSlackHealthAlerts } = require('./skills/skill-planner');
+        const { getSlackSocketModeStatus } = require('./slack/socket-mode-listener');
+        const authenticated = await slackMcp.isAuthenticated();
+        const token = slackMcp.loadToken();
+        const owner = getSlackOwnerRepairState();
+        let clearedAlerts = 0;
+        if (authenticated) {
+          try {
+            const cleared = clearResolvedSlackHealthAlerts({
+              authenticated: true,
+              ownerConfigured: owner.configured,
+            });
+            clearedAlerts = cleared.cleared || 0;
+          } catch {}
+        }
+        jsonResponse(res, {
+          data: {
+            authenticated,
+            team: token?.team_name,
+            user: token?.user_id,
+            obtained_at: token?.obtained_at,
+            owner_configured: owner.configured,
+            owner_can_repair: owner.canRepair,
+            socket_mode: getSlackSocketModeStatus(),
+            cleared_stale_alerts: clearedAlerts,
+          },
+        });
+      } catch (e) {
+        jsonResponse(res, { data: { authenticated: false, error: e.message } });
+      }
+    })();
+    return true;
+  }
+
+  // POST /api/wall-e/slack/repair-owner — derive Slack owner id from OAuth token
+  if (p === '/api/wall-e/slack/repair-owner' && m === 'POST') {
     try {
-      const slackMcp = require('./tools/slack-mcp');
-      const token = slackMcp.loadToken();
-      jsonResponse(res, { data: { authenticated: !!token?.access_token, team: token?.team_name, user: token?.user_id, obtained_at: token?.obtained_at } });
+      const { repairSlackOwnerIdentity } = require('./tools/slack-owner');
+      const { clearServiceAlerts } = require('./skills/skill-planner');
+      const result = repairSlackOwnerIdentity({ persist: true });
+      if (!result.ok) {
+        return jsonResponse(res, {
+          ok: false,
+          error: result.error || 'Could not repair Slack owner identity',
+          needsSlackAuth: !!result.needsSlackAuth,
+        }, result.needsSlackAuth ? 409 : 500), true;
+      }
+      clearServiceAlerts('slack');
+      return jsonResponse(res, {
+        ok: true,
+        user_id_configured: true,
+        source: result.source,
+        persisted: !!result.persisted,
+        already_configured: !!result.alreadyConfigured,
+      }), true;
     } catch (e) {
-      jsonResponse(res, { data: { authenticated: false } });
+      return jsonResponse(res, { ok: false, error: e.message }, 500), true;
     }
-    return true;
   }
 
   // POST /api/wall-e/slack/auth — start OAuth flow (opens browser)
@@ -378,11 +517,27 @@ function handleWalleApi(req, res, url) {
       const slackMcp = require('./tools/slack-mcp');
       // If already authenticated, return immediately
       if (slackMcp.isAuthenticatedSync()) {
+        try {
+          const { repairSlackOwnerIdentity } = require('./tools/slack-owner');
+          const { clearServiceAlerts } = require('./skills/skill-planner');
+          const repaired = repairSlackOwnerIdentity({ persist: true });
+          if (repaired.ok) clearServiceAlerts('slack');
+        } catch (repairErr) {
+          console.warn('[wall-e] Slack owner repair skipped:', repairErr.message);
+        }
         jsonResponse(res, { ok: true, already: true });
         return true;
       }
       // Start OAuth — opens browser, temp server on port 3118 handles callback
       slackMcp.authenticate().then(() => {
+        try {
+          const { repairSlackOwnerIdentity } = require('./tools/slack-owner');
+          const { clearServiceAlerts } = require('./skills/skill-planner');
+          const repaired = repairSlackOwnerIdentity({ persist: true });
+          if (repaired.ok) clearServiceAlerts('slack');
+        } catch (repairErr) {
+          console.error('[wall-e] Slack owner repair failed:', repairErr.message);
+        }
         console.log('[wall-e] Slack OAuth completed');
       }).catch(err => {
         console.error('[wall-e] Slack OAuth failed:', err.message);
@@ -714,24 +869,9 @@ function handleWalleApi(req, res, url) {
   // GET /api/wall-e/mcp/integrations — check which AI tools have Wall-E MCP configured
   if (p === '/api/wall-e/mcp/integrations' && m === 'GET') {
     try {
-      const fs = require('fs');
-      const { MCP_TARGETS } = require('../create-walle/bin/mcp-inject');
+      const { detectMcpIntegrations } = require('./lib/mcp-integration');
       const wallePort = parseInt(process.env.WALL_E_PORT) || 3457;
-      const home = process.env.HOME;
-      const results = MCP_TARGETS.map(target => {
-        const detectPath = path.join(home, target.detectDir);
-        const configPath = path.join(home, target.configPath);
-        if (!fs.existsSync(detectPath)) return { tool: target.tool, status: 'not_installed' };
-        try {
-          const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-          const entry = config?.mcpServers?.['wall-e'];
-          if (entry && entry.url === `http://localhost:${wallePort}/mcp`) return { tool: target.tool, status: 'configured', configPath };
-          if (entry) return { tool: target.tool, status: 'wrong_port', configPath };
-          return { tool: target.tool, status: 'not_configured', configPath };
-        } catch {
-          return { tool: target.tool, status: 'not_configured', configPath };
-        }
-      });
+      const results = detectMcpIntegrations(wallePort);
       jsonResponse(res, { data: results, wallePort });
     } catch (e) {
       jsonResponse(res, { data: [], error: e.message });
@@ -742,11 +882,12 @@ function handleWalleApi(req, res, url) {
   // POST /api/wall-e/mcp/inject — run MCP config injection for all detected AI tools
   if (p === '/api/wall-e/mcp/inject' && m === 'POST') {
     try {
-      const { injectMcpConfigs } = require('../create-walle/bin/mcp-inject');
+      const { ensureMcpIntegrations } = require('./lib/mcp-integration');
       const wallePort = parseInt(process.env.WALL_E_PORT) || 3457;
-      const results = injectMcpConfigs(wallePort);
-      const added = results.filter(r => r.action === 'added' || r.action === 'updated').length;
-      try { require('./telemetry').track('mcp_inject', { added, total: results.length }); } catch {}
+      const results = ensureMcpIntegrations(wallePort);
+      const added = results.filter(r => r.kind === 'mcp_config' && (r.action === 'added' || r.action === 'updated')).length;
+      const instructions = results.filter(r => r.kind === 'agent_instructions' && (r.action === 'added' || r.action === 'updated')).length;
+      try { require('./telemetry').track('mcp_inject', { added, instructions, total: results.length }); } catch {}
       jsonResponse(res, { ok: true, results });
     } catch (e) {
       jsonResponse(res, { ok: false, error: e.message });
@@ -754,6 +895,20 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  // GET /api/wall-e/mcp/test - verify the live Wall-E MCP endpoint responds
+  if (p === '/api/wall-e/mcp/test' && m === 'GET') {
+    try {
+      const { testWallEMcpEndpoint } = require('./lib/mcp-integration');
+      const wallePort = parseInt(process.env.WALL_E_PORT) || 3457;
+      testWallEMcpEndpoint(wallePort, { timeoutMs: 1500 })
+        .then(result => jsonResponse(res, { data: result, wallePort }))
+        .catch(e => jsonResponse(res, { data: { ok: false, error: e.message }, wallePort }, 500));
+    } catch (e) {
+      jsonResponse(res, { data: { ok: false, error: e.message } }, 500);
+    }
+    return true;
+  }
+
   // GET /api/wall-e/status
   if (p === '/api/wall-e/status' && m === 'GET') {
     const result = getStatus();
@@ -862,6 +1017,12 @@ function handleWalleApi(req, res, url) {
       serviceAlerts = getServiceAlerts({ includeVersionUpdate: true });
     } catch {}
 
+    let slackSocketMode = null;
+    try {
+      const { getSlackSocketModeStatus } = require('./slack/socket-mode-listener');
+      slackSocketMode = getSlackSocketModeStatus();
+    } catch {}
+
     return jsonResponse(res, {
       data: {
         ...result,
@@ -878,6 +1039,7 @@ function handleWalleApi(req, res, url) {
         walle_model: walleModel,
         has_api_key: hasApiKey,
         service_alerts: serviceAlerts,
+        slack_socket_mode: slackSocketMode,
       }
     }), true;
   }
@@ -964,32 +1126,49 @@ function handleWalleApi(req, res, url) {
         const providerConfig = body.providerConfig || null;
 
         if (provider) {
-          brain.setKv('walle_provider', provider);
-          process.env.WALLE_PROVIDER = provider;
-        }
-        if (model) {
+          if (typeof brain.setDefaultProviderSelection === 'function') {
+            brain.setDefaultProviderSelection({ type: provider, requestedModel: model, targetModel: model || brain.getKv('walle_model') || '' });
+          } else {
+            brain.setKv('walle_provider', provider);
+            process.env.WALLE_PROVIDER = provider;
+            if (model) {
+              brain.setKv('walle_model', model);
+              process.env.WALLE_MODEL = model;
+            }
+          }
+        } else if (model) {
           brain.setKv('walle_model', model);
-          process.env.WALLE_MODEL = model;
         }
         if (ownerName) brain.setKv('walle_owner_name', ownerName);
 
         if (provider && providerConfig) {
-          const providerNames = { anthropic: 'Anthropic', openai: 'OpenAI', google: 'Google Gemini', deepseek: 'DeepSeek', ollama: 'Ollama (Local)', mlx: 'MLX (Local)' };
-          brain.upsertModelProvider({
-            id: providerConfig.id || `${provider}-default`,
-            name: providerConfig.name || providerNames[provider] || provider,
-            type: provider,
-            baseUrl: providerConfig.baseUrl || null,
-            apiKeyEncrypted: providerConfig.apiKeyEncrypted || null,
-            customHeaders: providerConfig.customHeaders || null,
-            enabled: true,
-          });
+          if (typeof brain.saveSetupProvider === 'function') {
+            brain.saveSetupProvider({
+              id: providerConfig.id || `${provider}-default`,
+              name: providerConfig.name || SETUP_PROVIDER_NAMES[provider] || provider,
+              type: provider,
+              baseUrl: providerConfig.baseUrl || null,
+              apiKeyEncrypted: providerConfig.apiKeyEncrypted || null,
+              customHeaders: providerConfig.customHeaders || null,
+              enabled: true,
+              model,
+              setDefault: false,
+            });
+          } else {
+            brain.upsertModelProvider({
+              id: providerConfig.id || `${provider}-default`,
+              name: providerConfig.name || SETUP_PROVIDER_NAMES[provider] || provider,
+              type: provider,
+              baseUrl: providerConfig.baseUrl || null,
+              apiKeyEncrypted: providerConfig.apiKeyEncrypted || null,
+              customHeaders: providerConfig.customHeaders || null,
+              enabled: true,
+            });
+          }
         }
 
-        try {
-          const { resetDefaultClient } = require('./llm/client');
-          resetDefaultClient();
-        } catch {}
+        syncRuntimeDefaultsFromBrain();
+        resetDefaultClientQuiet();
 
         jsonResponse(res, { ok: true });
       } catch (e) {
@@ -999,6 +1178,88 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  if (p === '/api/wall-e/setup/provider' && m === 'POST') {
+    readBody(req).then((body) => {
+      try {
+        if (!brain || !ensureBrainInit()) return jsonResponse(res, { ok: false, error: 'Brain module not available' }, 503);
+        const type = sanitizeSetupProviderType(body.type);
+        if (!type) return jsonResponse(res, { ok: false, error: 'Invalid provider type' }, 400);
+        const model = sanitizeSetupModel(body.model);
+        const result = brain.saveSetupProvider({
+          id: body.id || `${type}-default`,
+          name: body.name || SETUP_PROVIDER_NAMES[type] || type,
+          type,
+          baseUrl: body.base_url || body.baseUrl || null,
+          apiKeyEncrypted: typeof body.api_key === 'string' ? body.api_key.replace(/[\r\n\s]/g, '').slice(0, 200) : (body.apiKeyEncrypted || null),
+          customHeaders: body.custom_headers || body.customHeaders || null,
+          enabled: body.enabled !== false,
+          model,
+          setDefault: Boolean(body.set_default),
+          authMethod: body.auth_method || null,
+        });
+        syncRuntimeDefaultsFromBrain();
+        resetDefaultClientQuiet();
+        jsonResponse(res, { ok: true, authority: 'wall-e', ...result });
+      } catch (e) {
+        jsonResponse(res, { ok: false, error: e.message }, 400);
+      }
+    }).catch((e) => jsonResponse(res, { ok: false, error: e.message }, 400));
+    return true;
+  }
+
+  if (p === '/api/wall-e/setup/default-provider' && m === 'POST') {
+    readBody(req).then((body) => {
+      try {
+        if (!brain || !ensureBrainInit()) return jsonResponse(res, { ok: false, error: 'Brain module not available' }, 503);
+        const type = sanitizeSetupProviderType(body.type);
+        if (!type) return jsonResponse(res, { ok: false, error: 'Invalid provider type' }, 400);
+        const requestedModel = sanitizeSetupModel(body.requested_model ?? body.requestedModel ?? body.model);
+        const targetModel = sanitizeSetupModel(body.target_model ?? body.targetModel ?? body.model);
+        const result = brain.setDefaultProviderSelection({ type, requestedModel, targetModel });
+        syncRuntimeDefaultsFromBrain();
+        resetDefaultClientQuiet();
+        jsonResponse(res, { ok: true, authority: 'wall-e', ...result });
+      } catch (e) {
+        jsonResponse(res, { ok: false, error: e.message }, 400);
+      }
+    }).catch((e) => jsonResponse(res, { ok: false, error: e.message }, 400));
+    return true;
+  }
+
+  const setupProviderDelete = p.match(/^\/api\/wall-e\/setup\/provider\/([a-z0-9_-]+)$/);
+  if (setupProviderDelete && m === 'DELETE') {
+    try {
+      if (!brain || !ensureBrainInit()) return jsonResponse(res, { ok: false, error: 'Brain module not available' }, 503), true;
+      const type = sanitizeSetupProviderType(setupProviderDelete[1]);
+      if (!type) return jsonResponse(res, { ok: false, error: 'Invalid provider type' }, 400), true;
+      const result = brain.disableModelProviderByType(type);
+      syncRuntimeDefaultsFromBrain();
+      resetDefaultClientQuiet();
+      jsonResponse(res, { ok: true, authority: 'wall-e', ...result });
+    } catch (e) {
+      jsonResponse(res, { ok: false, error: e.message }, 400);
+    }
+    return true;
+  }
+
+  if (p === '/api/wall-e/setup/task-default' && m === 'POST') {
+    readBody(req).then((body) => {
+      try {
+        if (!brain || !ensureBrainInit()) return jsonResponse(res, { ok: false, error: 'Brain module not available' }, 503);
+        const taskType = sanitizeTaskType(body.task_type);
+        if (!taskType) return jsonResponse(res, { ok: false, error: 'task_type required (alphanumeric/underscore/hyphen)' }, 400);
+        const modelRegistryId = sanitizeModelRegistryId(body.model_registry_id);
+        const strategy = typeof body.strategy === 'string' && /^(single|quorum)$/.test(body.strategy) ? body.strategy : 'single';
+        const quorumSize = Number.isInteger(body.quorum_size) && body.quorum_size > 0 && body.quorum_size <= 10 ? body.quorum_size : 1;
+        const result = brain.setTaskModelDefault({ taskType, modelRegistryId, strategy, quorumSize });
+        jsonResponse(res, { ok: true, authority: 'wall-e', ...result });
+      } catch (e) {
+        jsonResponse(res, { ok: false, error: e.message }, 400);
+      }
+    }).catch((e) => jsonResponse(res, { ok: false, error: e.message }, 400));
+    return true;
+  }
+
   if (p === '/api/wall-e/prompt-embeddings/upsert' && m === 'POST') {
     readBody(req).then(async (body) => {
       try {
@@ -3849,7 +4110,11 @@ function handleWalleApi(req, res, url) {
     if (!tdb) return jsonResponse(res, { error: 'Telemetry not enabled' }, 404), true;
     // Basic rate limiting: max 60 requests per minute per IP
     const clientIpRL = (req.headers['x-forwarded-for'] || '').split(',')[0].trim() || req.socket?.remoteAddress || 'unknown';
-    if (!handleWalleApi._rlMap) { handleWalleApi._rlMap = new Map(); setInterval(() => handleWalleApi._rlMap.clear(), 60000); }
+    if (!handleWalleApi._rlMap) {
+      handleWalleApi._rlMap = new Map();
+      handleWalleApi._rlTimer = setInterval(() => handleWalleApi._rlMap.clear(), 60000);
+      if (typeof handleWalleApi._rlTimer.unref === 'function') handleWalleApi._rlTimer.unref();
+    }
     const rlCount = (handleWalleApi._rlMap.get(clientIpRL) || 0) + 1;
     handleWalleApi._rlMap.set(clientIpRL, rlCount);
     if (rlCount > 60) return jsonResponse(res, { error: 'Rate limited' }, 429), true;
@@ -3860,25 +4125,29 @@ function handleWalleApi(req, res, url) {
       // Capture client IP from request (supports reverse proxy headers)
       const clientIp = (req.headers['x-forwarded-for'] || '').split(',')[0].trim()
         || req.socket?.remoteAddress || '';
+      const machineBucket = typeof body.machine === 'string' && /^[a-f0-9]{12,64}$/i.test(body.machine)
+        ? body.machine.toLowerCase().slice(0, 64)
+        : null;
       const insertEvent = tdb.prepare(
         'INSERT INTO telemetry_events (install_id, version, os, node_version, event, meta, client_ts, ip) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
       );
       const upsertInstall = tdb.prepare(`
-        INSERT INTO telemetry_installs (install_id, version, os, node_version, ip, event_count)
-        VALUES (?, ?, ?, ?, ?, ?)
+        INSERT INTO telemetry_installs (install_id, version, os, node_version, ip, machine_bucket, event_count)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(install_id) DO UPDATE SET
           last_seen = datetime('now'),
           version = excluded.version,
           os = excluded.os,
           node_version = excluded.node_version,
           ip = excluded.ip,
+          machine_bucket = COALESCE(excluded.machine_bucket, telemetry_installs.machine_bucket),
           event_count = telemetry_installs.event_count + excluded.event_count
       `);
       const runBatch = tdb.transaction((events) => {
         for (const ev of events) {
           insertEvent.run(body.id, body.v, body.os, body.node, ev.e, JSON.stringify(ev.m || {}), ev.t, clientIp);
         }
-        upsertInstall.run(body.id, body.v, body.os, body.node, clientIp, events.length);
+        upsertInstall.run(body.id, body.v, body.os, body.node, clientIp, machineBucket, events.length);
       });
       runBatch(body.events.slice(0, 500)); // cap at 500 events per request
       jsonResponse(res, { ok: true, received: Math.min(body.events.length, 500) });
@@ -3899,6 +4168,12 @@ function handleWalleApi(req, res, url) {
     const summary = {
       total_installs: tdb.prepare('SELECT count(*) as cnt FROM telemetry_installs').get().cnt,
       active_installs: tdb.prepare('SELECT count(*) as cnt FROM telemetry_installs WHERE last_seen >= ?').get(since).cnt,
+      unique_machines: tdb.prepare(
+        "SELECT count(DISTINCT machine_bucket) as cnt FROM telemetry_installs WHERE machine_bucket IS NOT NULL AND machine_bucket != ''"
+      ).get().cnt,
+      active_machines: tdb.prepare(
+        "SELECT count(DISTINCT machine_bucket) as cnt FROM telemetry_installs WHERE last_seen >= ? AND machine_bucket IS NOT NULL AND machine_bucket != ''"
+      ).get(since).cnt,
       total_events: tdb.prepare('SELECT count(*) as cnt FROM telemetry_events WHERE received_at >= ?').get(since).cnt,
       events_by_type: tdb.prepare(
         'SELECT event, count(*) as cnt FROM telemetry_events WHERE received_at >= ? GROUP BY event ORDER BY cnt DESC LIMIT 50'
@@ -3922,6 +4197,9 @@ function handleWalleApi(req, res, url) {
         "SELECT date(received_at) as day, count(DISTINCT install_id) as users, count(*) as events FROM telemetry_events WHERE received_at >= ? GROUP BY day ORDER BY day DESC LIMIT ?"
       ).all(since, days),
     };
+    summary.install_machine_ratio = summary.unique_machines > 0
+      ? Math.round(summary.total_installs / summary.unique_machines * 100) / 100
+      : null;
 
     // Compat lifecycle data (Phase 4)
     try {