neoagent 2.4.1-beta.28 → 2.4.1-beta.29

package/server/routes/workspace.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const express = require('express');
+const { requireAuth } = require('../middleware/auth');
+const { sanitizeError } = require('../utils/security');
+
+const router = express.Router();
+
+const MAX_PATH_LENGTH = 2048;
+const MAX_EDIT_BYTES = 1024 * 1024;
+
+router.use(requireAuth);
+
+function badRequest(message) {
+  const error = new Error(message);
+  error.status = 400;
+  return error;
+}
+
+function parseWorkspacePath(value, fallback = '.') {
+  const normalized = String(value ?? fallback).trim();
+  if (normalized.length > MAX_PATH_LENGTH) {
+    throw badRequest('path is too long.');
+  }
+  return normalized || fallback;
+}
+
+function getWorkspace(req) {
+  const workspace = req.app?.locals?.workspaceManager;
+  if (!workspace) {
+    const error = new Error('Workspace service is unavailable.');
+    error.status = 503;
+    throw error;
+  }
+  return workspace;
+}
+
+function handleWorkspaceAction(req, res, action) {
+  try {
+    const result = action(getWorkspace(req));
+    return res.json(result);
+  } catch (err) {
+    return res.status(err.status || 500).json({ error: sanitizeError(err), code: err.code || null });
+  }
+}
+
+router.get('/files', (req, res) => handleWorkspaceAction(req, res, (workspace) =>
+  workspace.listExplorerDirectory(req.session.userId, {
+    path: parseWorkspacePath(req.query?.path, '.'),
+  })));
+
+router.get('/files/content', (req, res) => handleWorkspaceAction(req, res, (workspace) =>
+  workspace.readExplorerFile(req.session.userId, {
+    path: parseWorkspacePath(req.query?.path, ''),
+    maxBytes: MAX_EDIT_BYTES,
+  })));
+
+router.put('/files/content', (req, res) => handleWorkspaceAction(req, res, (workspace) => {
+  const content = String(req.body?.content ?? '');
+  if (Buffer.byteLength(content, 'utf8') > MAX_EDIT_BYTES) {
+    throw badRequest('content is too large.');
+  }
+  return workspace.writeExplorerFile(req.session.userId, {
+    path: parseWorkspacePath(req.body?.path, ''),
+    content,
+  });
+}));
+
+router.get('/files/download', (req, res) => {
+  try {
+    const workspace = getWorkspace(req);
+    const file = workspace.getExplorerDownload(req.session.userId, {
+      path: parseWorkspacePath(req.query?.path, ''),
+    });
+    res.setHeader('Cache-Control', 'private, no-store');
+    return res.download(file.absolutePath, file.filename, (err) => {
+      if (!err || res.headersSent) return;
+      const status = err.code === 'ENOENT' || err.code === 'EACCES' ? 404 : 500;
+      res.status(status).json({ error: status === 404 ? 'File not found' : 'Failed to download file' });
+    });
+  } catch (err) {
+    return res.status(err.status || 500).json({ error: sanitizeError(err), code: err.code || null });
+  }
+});
+
+module.exports = router;

package/server/services/integrations/home_assistant/constants.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const HOME_ASSISTANT_PROVIDER_KEY = 'home_assistant';
+
+const HOME_ASSISTANT_APP = {
+  id: 'home_assistant',
+  label: 'Home Assistant',
+  description: 'Connect one Home Assistant instance for states and service calls.',
+};
+
+const HOME_ASSISTANT_TOOL_DEFINITIONS = [
+  {
+    appId: HOME_ASSISTANT_APP.id,
+    name: 'home_assistant_get_config',
+    access: 'read',
+    description: 'Get basic configuration for the connected Home Assistant instance.',
+    parameters: { type: 'object', properties: {} },
+  },
+  {
+    appId: HOME_ASSISTANT_APP.id,
+    name: 'home_assistant_list_states',
+    access: 'read',
+    description: 'List Home Assistant entity states. Use entity_domain to narrow results such as light, sensor, switch, climate, or automation.',
+    parameters: {
+      type: 'object',
+      properties: {
+        entity_domain: {
+          type: 'string',
+          description: 'Optional entity domain prefix before the dot, for example light or sensor.',
+        },
+        limit: { type: 'number', description: 'Maximum number of states to return, default 100.' },
+      },
+    },
+  },
+  {
+    appId: HOME_ASSISTANT_APP.id,
+    name: 'home_assistant_get_state',
+    access: 'read',
+    description: 'Get one Home Assistant entity state by entity_id.',
+    parameters: {
+      type: 'object',
+      properties: {
+        entity_id: { type: 'string', description: 'Home Assistant entity ID, for example light.kitchen.' },
+      },
+      required: ['entity_id'],
+    },
+  },
+  {
+    appId: HOME_ASSISTANT_APP.id,
+    name: 'home_assistant_call_service',
+    access: 'write',
+    description: 'Call a Home Assistant service such as light.turn_on or script.turn_on.',
+    parameters: {
+      type: 'object',
+      properties: {
+        domain: { type: 'string', description: 'Service domain, for example light, switch, climate, script, or automation.' },
+        service: { type: 'string', description: 'Service name, for example turn_on, turn_off, toggle, set_temperature, or reload.' },
+        service_data: { type: 'object', description: 'Optional Home Assistant service payload.' },
+      },
+      required: ['domain', 'service'],
+    },
+  },
+  {
+    appId: HOME_ASSISTANT_APP.id,
+    name: 'home_assistant_api_request',
+    access: 'dynamic_http_method',
+    description: 'Make an authenticated Home Assistant REST API request under /api for advanced operations.',
+    parameters: {
+      type: 'object',
+      properties: {
+        method: { type: 'string', description: 'HTTP method: GET, POST, PUT, PATCH, or DELETE.' },
+        path: { type: 'string', description: 'Path under the same Home Assistant origin. Must start with /api/.' },
+        query: { type: 'object', description: 'Optional query parameters.' },
+        body: { type: 'object', description: 'Optional JSON request body.' },
+      },
+      required: ['method', 'path'],
+    },
+  },
+];
+
+const toolAppMap = new Map(HOME_ASSISTANT_TOOL_DEFINITIONS.map((tool) => [tool.name, tool.appId]));
+
+module.exports = {
+  HOME_ASSISTANT_APP,
+  HOME_ASSISTANT_PROVIDER_KEY,
+  HOME_ASSISTANT_TOOL_DEFINITIONS,
+  toolAppMap,
+};

package/server/services/integrations/home_assistant/network.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const dns = require('dns').promises;
+const net = require('net');
+
+const HTTP_TIMEOUT_MS = 15000;
+const ALLOWED_PORTS = new Set(['', '443', '8123']);
+
+function trimText(value) {
+  return String(value || '').trim();
+}
+
+function requireText(value, label) {
+  const text = trimText(value);
+  if (!text) throw new Error(`${label} is required.`);
+  return text;
+}
+
+function normalizeHomeAssistantBaseUrl(value) {
+  const raw = requireText(value, 'Home Assistant URL');
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error('Home Assistant URL must be a valid absolute HTTPS URL.');
+  }
+
+  if (parsed.protocol !== 'https:') {
+    throw new Error('Home Assistant URL must use HTTPS.');
+  }
+  if (parsed.username || parsed.password) {
+    throw new Error('Home Assistant URL must not include credentials.');
+  }
+  if (!ALLOWED_PORTS.has(parsed.port)) {
+    throw new Error('Home Assistant URL must use port 443 or 8123.');
+  }
+  parsed.hash = '';
+  parsed.search = '';
+  parsed.pathname = parsed.pathname.replace(/\/+$/, '');
+  return parsed.toString().replace(/\/$/, '');
+}
+
+function ipv4ToNumber(address) {
+  const parts = String(address || '').split('.').map((part) => Number(part));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return null;
+  }
+  return parts.reduce((acc, part) => ((acc << 8) + part) >>> 0, 0);
+}
+
+function ipv4InCidr(address, cidr, bits) {
+  const value = ipv4ToNumber(address);
+  const base = ipv4ToNumber(cidr);
+  if (value === null || base === null) return false;
+  const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+  return (value & mask) === (base & mask);
+}
+
+function isBlockedIpv4(address) {
+  return [
+    ['0.0.0.0', 8],
+    ['10.0.0.0', 8],
+    ['100.64.0.0', 10],
+    ['127.0.0.0', 8],
+    ['169.254.0.0', 16],
+    ['172.16.0.0', 12],
+    ['192.0.0.0', 24],
+    ['192.0.2.0', 24],
+    ['192.168.0.0', 16],
+    ['198.18.0.0', 15],
+    ['198.51.100.0', 24],
+    ['203.0.113.0', 24],
+    ['224.0.0.0', 4],
+    ['240.0.0.0', 4],
+  ].some(([cidr, bits]) => ipv4InCidr(address, cidr, bits));
+}
+
+function isBlockedIpv6(address) {
+  const normalized = String(address || '').trim().toLowerCase();
+  if (normalized.startsWith('::ffff:')) {
+    return isBlockedIpv4(normalized.slice('::ffff:'.length));
+  }
+  return normalized === '::' ||
+    normalized === '::1' ||
+    normalized.startsWith('fc') ||
+    normalized.startsWith('fd') ||
+    normalized.startsWith('fe8') ||
+    normalized.startsWith('fe9') ||
+    normalized.startsWith('fea') ||
+    normalized.startsWith('feb') ||
+    normalized.startsWith('ff') ||
+    normalized.startsWith('2001:db8:');
+}
+
+function isBlockedIpAddress(address) {
+  const normalized = String(address || '').trim().replace(/^\[|\]$/g, '');
+  const family = net.isIP(normalized);
+  if (family === 4) return isBlockedIpv4(normalized);
+  if (family === 6) return isBlockedIpv6(normalized);
+  return true;
+}
+
+async function assertPublicHomeAssistantEndpoint(baseUrl) {
+  const url = new URL(normalizeHomeAssistantBaseUrl(baseUrl));
+  const hostname = String(url.hostname || '').replace(/^\[|\]$/g, '');
+  if (net.isIP(hostname) && isBlockedIpAddress(hostname)) {
+    throw new Error('Home Assistant URL must not point to a private, loopback, or link-local address.');
+  }
+
+  let addresses;
+  try {
+    addresses = await dns.lookup(hostname, { all: true, verbatim: true });
+  } catch (error) {
+    throw new Error(`Could not resolve Home Assistant host: ${error?.message || 'DNS lookup failed'}`);
+  }
+
+  if (!Array.isArray(addresses) || addresses.length === 0) {
+    throw new Error('Could not resolve Home Assistant host.');
+  }
+  if (addresses.some((entry) => isBlockedIpAddress(entry.address))) {
+    throw new Error('Home Assistant URL resolves to a private, loopback, or reserved address.');
+  }
+}
+
+function buildHomeAssistantUrl(baseUrl, path, query = {}) {
+  const base = new URL(normalizeHomeAssistantBaseUrl(baseUrl));
+  const url = new URL(requireText(path, 'path'), base);
+  if (url.origin !== base.origin || !url.pathname.startsWith('/api/')) {
+    throw new Error('Home Assistant API path must stay on the connected origin and start with /api/.');
+  }
+  for (const [key, value] of Object.entries(query || {})) {
+    if (value === undefined || value === null) continue;
+    const text = String(value).trim();
+    if (!text) continue;
+    url.searchParams.set(key, text);
+  }
+  return url.toString();
+}
+
+async function homeAssistantRequest(credentials, options = {}) {
+  const baseUrl = normalizeHomeAssistantBaseUrl(credentials.baseUrl);
+  const token = requireText(credentials.token, 'Home Assistant token');
+  await assertPublicHomeAssistantEndpoint(baseUrl);
+
+  const method = String(options.method || 'GET').trim().toUpperCase();
+  if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
+    throw new Error('Unsupported Home Assistant API method.');
+  }
+
+  const headers = { Accept: 'application/json', Authorization: `Bearer ${token}` };
+  let body;
+  if (options.body !== undefined && options.body !== null) {
+    headers['Content-Type'] = 'application/json';
+    body = JSON.stringify(options.body);
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(buildHomeAssistantUrl(baseUrl, options.path, options.query), {
+      method,
+      headers,
+      body,
+      redirect: 'manual',
+      signal: controller.signal,
+    });
+  } catch (error) {
+    if (error?.name === 'AbortError') {
+      throw new Error(`Home Assistant request timed out after ${HTTP_TIMEOUT_MS}ms.`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (response.status >= 300 && response.status < 400) {
+    throw new Error('Home Assistant redirected the API request; redirects are not followed.');
+  }
+
+  const text = await response.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+
+  if (!response.ok) {
+    const message = data && typeof data === 'object'
+      ? data.message || data.error || `${response.status} ${response.statusText}`
+      : text || `${response.status} ${response.statusText}`;
+    throw new Error(`Home Assistant request failed: ${String(message).trim()}`);
+  }
+
+  return data;
+}
+
+module.exports = {
+  assertPublicHomeAssistantEndpoint,
+  buildHomeAssistantUrl,
+  homeAssistantRequest,
+  isBlockedIpAddress,
+  normalizeHomeAssistantBaseUrl,
+  requireText,
+  trimText,
+};

package/server/services/integrations/home_assistant/provider.js

@@ -0,0 +1,249 @@
+'use strict';
+
+const db = require('../../../db/database');
+const { resolveAgentId } = require('../../agents/manager');
+const {
+  deleteProviderConfig,
+  getProviderConfig,
+  setProviderConfig,
+} = require('../provider_config_store');
+const { getConnectionAccessMode } = require('../access');
+const { encryptValue } = require('../secrets');
+const {
+  HOME_ASSISTANT_APP,
+  HOME_ASSISTANT_PROVIDER_KEY,
+  HOME_ASSISTANT_TOOL_DEFINITIONS,
+  toolAppMap,
+} = require('./constants');
+const {
+  assertPublicHomeAssistantEndpoint,
+  buildHomeAssistantUrl,
+  isBlockedIpAddress,
+  normalizeHomeAssistantBaseUrl,
+  trimText,
+} = require('./network');
+const { buildHomeAssistantSnapshot } = require('./snapshot');
+const {
+  executeHomeAssistantTool,
+  fetchHomeAssistantConfig,
+  parseCredentials,
+} = require('./tools');
+
+function parseJsonObject(value) {
+  try {
+    const parsed = JSON.parse(String(value || '{}'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function parseConfigInput(rawConfig, existingConfig = {}) {
+  const source = rawConfig && typeof rawConfig === 'object' ? rawConfig : {};
+  return {
+    baseUrl: trimText(source.baseUrl) || trimText(existingConfig.baseUrl),
+    token: trimText(source.token) || trimText(existingConfig.token),
+  };
+}
+
+function accountEmailForConfig(baseUrl, config = {}) {
+  const host = new URL(normalizeHomeAssistantBaseUrl(baseUrl)).host;
+  const location = trimText(config.location_name);
+  return `home_assistant:${location || host}`;
+}
+
+function resolveHomeAssistantEnvStatus(userId, agentId = null) {
+  const normalizedUserId = Number(userId);
+  const config = Number.isInteger(normalizedUserId) && normalizedUserId > 0
+    ? parseConfigInput(getProviderConfig(normalizedUserId, HOME_ASSISTANT_PROVIDER_KEY, agentId))
+    : { baseUrl: '', token: '' };
+  const missing = [];
+  if (!config.baseUrl) missing.push('baseUrl');
+  if (!config.token) missing.push('token');
+  return {
+    configured: missing.length === 0,
+    missing,
+    summary: missing.length === 0
+      ? 'Home Assistant is ready for account connections.'
+      : 'Add your Home Assistant HTTPS URL and a Long-Lived Access Token in Official Integrations.',
+    setupMode: 'user',
+  };
+}
+
+function sanitizeHomeAssistantConfigForClient(rawConfig) {
+  const config = parseConfigInput(rawConfig);
+  return {
+    baseUrl: config.baseUrl,
+    hasToken: Boolean(config.token),
+    configured: Boolean(config.baseUrl && config.token),
+  };
+}
+
+function loadExistingConnection(userId, agentId) {
+  return db
+    .prepare(
+      `SELECT *
+       FROM integration_connections
+       WHERE user_id = ? AND agent_id = ? AND provider_key = ?
+       ORDER BY updated_at DESC, id DESC
+       LIMIT 1`,
+    )
+    .get(userId, agentId, HOME_ASSISTANT_PROVIDER_KEY);
+}
+
+function upsertHomeAssistantConnection(userId, agentId, baseUrl, token, config) {
+  const existing = loadExistingConnection(userId, agentId);
+  const accessMode = getConnectionAccessMode(existing || null);
+  const metadata = {
+    ...parseJsonObject(existing?.metadata_json || '{}'),
+    access_mode: accessMode,
+    locationName: config?.location_name || null,
+    version: config?.version || null,
+    timeZone: config?.time_zone || null,
+  };
+  const accountEmail = accountEmailForConfig(baseUrl, config);
+
+  db.prepare(
+    `INSERT INTO integration_connections (
+       user_id, agent_id, provider_key, app_key, status, account_email,
+       scopes_json, credentials_json, metadata_json, last_connected_at, updated_at
+     ) VALUES (?, ?, ?, ?, 'connected', ?, ?, ?, ?, datetime('now'), datetime('now'))
+     ON CONFLICT(user_id, agent_id, provider_key, app_key, account_email) DO UPDATE SET
+       status = excluded.status,
+       scopes_json = excluded.scopes_json,
+       credentials_json = excluded.credentials_json,
+       metadata_json = excluded.metadata_json,
+       last_connected_at = excluded.last_connected_at,
+       updated_at = excluded.updated_at`,
+  ).run(
+    userId,
+    agentId,
+    HOME_ASSISTANT_PROVIDER_KEY,
+    HOME_ASSISTANT_APP.id,
+    accountEmail,
+    JSON.stringify(['home_assistant:api']),
+    encryptValue(JSON.stringify({ baseUrl, token })),
+    JSON.stringify(metadata),
+  );
+
+  if (existing && existing.account_email !== accountEmail) {
+    db.prepare('DELETE FROM integration_connections WHERE id = ? AND user_id = ? AND agent_id = ?')
+      .run(existing.id, userId, agentId);
+  }
+
+  return loadExistingConnection(userId, agentId);
+}
+
+function createHomeAssistantProvider() {
+  return {
+    key: HOME_ASSISTANT_PROVIDER_KEY,
+    label: 'Home Assistant',
+    description: 'Official Home Assistant integration for one user-managed HTTPS instance with state reads and service calls.',
+    icon: 'home_assistant',
+    apps: [HOME_ASSISTANT_APP],
+    connectPrompt: 'Save your Home Assistant HTTPS URL and a Long-Lived Access Token. Private and loopback network targets are blocked server-side.',
+    supportsMultipleAccounts: false,
+    connectionMethod: 'user_config',
+    getApp(appId) {
+      return String(appId || '').trim() === HOME_ASSISTANT_APP.id ? HOME_ASSISTANT_APP : null;
+    },
+    getToolAppId(toolName) {
+      return toolAppMap.get(String(toolName || '').trim()) || null;
+    },
+    getEnvStatus(context = {}) {
+      return resolveHomeAssistantEnvStatus(context.userId, context.agentId);
+    },
+    getToolDefinitions(options = {}) {
+      const connectedAppIds = new Set(options.connectedAppIds || []);
+      return connectedAppIds.has(HOME_ASSISTANT_APP.id) ? HOME_ASSISTANT_TOOL_DEFINITIONS.slice() : [];
+    },
+    supportsTool(toolName) {
+      return toolAppMap.has(String(toolName || '').trim());
+    },
+    buildSnapshot(connectionRows, context = {}) {
+      return buildHomeAssistantSnapshot(this, connectionRows, context);
+    },
+    summarizeForModel(snapshot) {
+      if (!snapshot?.env?.configured) {
+        return 'Home Assistant: setup is not complete for this user yet. Tell them to finish Home Assistant setup in Official Integrations first.';
+      }
+      if (!snapshot.connection?.connected) {
+        return 'Home Assistant: setup is ready, but no Home Assistant instance is connected yet. Tell the user to open Official Integrations and connect it.';
+      }
+      return 'Home Assistant: native Home Assistant access is connected in this run with tools for config, states, entity state, service calls, and /api requests.';
+    },
+    async executeTool(toolName, args, connection) {
+      return executeHomeAssistantTool(toolName, args, connection);
+    },
+    getUserConfig({ userId, agentId }) {
+      const normalizedUserId = Number(userId);
+      const scopedAgentId = resolveAgentId(normalizedUserId, agentId || null);
+      const storedConfig = getProviderConfig(normalizedUserId, HOME_ASSISTANT_PROVIDER_KEY, scopedAgentId);
+      const connection = loadExistingConnection(normalizedUserId, scopedAgentId);
+      return {
+        ...sanitizeHomeAssistantConfigForClient({ ...storedConfig, ...parseCredentials(connection) }),
+        accountCount: connection?.status === 'connected' ? 1 : 0,
+        hasConnectedAccount: connection?.status === 'connected',
+      };
+    },
+    async saveUserConfig({ userId, agentId, config }) {
+      const normalizedUserId = Number(userId);
+      if (!Number.isInteger(normalizedUserId) || normalizedUserId <= 0) {
+        throw new Error('A valid user is required to save Home Assistant configuration.');
+      }
+      const scopedAgentId = resolveAgentId(normalizedUserId, agentId || null);
+      const existingConnection = loadExistingConnection(normalizedUserId, scopedAgentId);
+      const existingConfig = parseConfigInput({
+        ...getProviderConfig(normalizedUserId, HOME_ASSISTANT_PROVIDER_KEY, scopedAgentId),
+        ...parseCredentials(existingConnection),
+      });
+      const parsedConfig = parseConfigInput(config, existingConfig);
+      const baseUrl = normalizeHomeAssistantBaseUrl(parsedConfig.baseUrl);
+      const token = parsedConfig.token;
+      if (!token) throw new Error('Home Assistant Long-Lived Access Token is required.');
+
+      const credentials = { baseUrl, token };
+      await assertPublicHomeAssistantEndpoint(baseUrl);
+      let haConfig;
+      try {
+        haConfig = await fetchHomeAssistantConfig(credentials);
+      } catch (error) {
+        const message = String(error?.message || '').toLowerCase();
+        if (message.includes('401') || message.includes('unauthorized')) {
+          throw new Error('Home Assistant rejected the token. Create a new Long-Lived Access Token and try again.');
+        }
+        throw error;
+      }
+
+      setProviderConfig(normalizedUserId, HOME_ASSISTANT_PROVIDER_KEY, { baseUrl, token }, scopedAgentId);
+      const connection = upsertHomeAssistantConnection(normalizedUserId, scopedAgentId, baseUrl, token, haConfig || {});
+      return {
+        ...sanitizeHomeAssistantConfigForClient({ baseUrl, token }),
+        accountCount: connection?.status === 'connected' ? 1 : 0,
+        hasConnectedAccount: connection?.status === 'connected',
+        accountEmail: connection?.account_email || null,
+        locationName: haConfig?.location_name || null,
+        version: haConfig?.version || null,
+      };
+    },
+    clearUserConfig({ userId, agentId }) {
+      const normalizedUserId = Number(userId);
+      if (!Number.isInteger(normalizedUserId) || normalizedUserId <= 0) {
+        throw new Error('A valid user is required to clear Home Assistant configuration.');
+      }
+      const scopedAgentId = resolveAgentId(normalizedUserId, agentId || null);
+      deleteProviderConfig(normalizedUserId, HOME_ASSISTANT_PROVIDER_KEY, scopedAgentId);
+      db.prepare('DELETE FROM integration_connections WHERE user_id = ? AND agent_id = ? AND provider_key = ?')
+        .run(normalizedUserId, scopedAgentId, HOME_ASSISTANT_PROVIDER_KEY);
+      return { cleared: true };
+    },
+  };
+}
+
+module.exports = {
+  assertPublicHomeAssistantEndpoint,
+  buildHomeAssistantUrl,
+  createHomeAssistantProvider,
+  isBlockedIpAddress,
+  normalizeHomeAssistantBaseUrl,
+};