neoagent 2.2.1-beta.8 → 2.3.1-beta.0

package/README.md

@@ -36,7 +36,7 @@ neoagent logs
 
 ## Links
 
-[Docs](https://neolabs-systems.github.io/NeoAgent/) | [Issues](https://github.com/NeoLabs-Systems/NeoAgent/issues)
+[Docs](https://neolabs-systems.github.io/NeoAgent/docs/) | [Homepage](https://neolabs-systems.github.io/NeoAgent/) | [Issues](https://github.com/NeoLabs-Systems/NeoAgent/issues)
 
 ---
 

package/docs/capabilities.md

@@ -75,10 +75,10 @@ The agent tool `read_health_data` returns summaries and recent samples. It is de
 
 NeoAgent has two separate integration layers:
 
-- Official integrations expose structured tools for Google Workspace, Microsoft 365, Notion, Slack, Figma, and a separate personal WhatsApp connection.
+- Official integrations expose structured tools for Google Workspace, Microsoft 365, Notion, Slack, Figma, Home Assistant, and a separate personal WhatsApp connection.
 - Messaging platforms let the agent talk through WhatsApp, Telegram, Discord, Slack, Google Chat, Teams, Matrix, Signal, iMessage/BlueBubbles, IRC, Twitch, LINE, Mattermost, configurable webhook bridges, and Telnyx Voice.
 
-Official integration examples include Gmail thread search and send mail, Google Calendar events, Drive upload/download/export/share links, Docs create/append/replace, Sheets read/update/append/create, Microsoft Outlook/Calendar/OneDrive/Teams tools, Notion search/page/block/database tools, Slack conversation/message tools, Figma file/node/comment/image tools, and a personal WhatsApp integration with isolated chat read/send tools and per-account read-only versus read/write access.
+Official integration examples include Gmail thread search and send mail, Google Calendar events, Drive upload/download/export/share links, Docs create/append/replace, Sheets read/update/append/create, Microsoft Outlook/Calendar/OneDrive/Teams tools, Notion search/page/block/database tools, Slack conversation/message tools, Figma file/node/comment/image tools, Home Assistant entity/config reads and service calls, and a personal WhatsApp integration with isolated chat read/send tools and per-account read-only versus read/write access.
 
 Messaging examples include Telegram and Discord messages, Slack channel replies, Matrix room messages, Google Chat and Teams webhook delivery, Signal bridge delivery, iMessage/BlueBubbles sends, WhatsApp text and media sends, Telnyx inbound voice, Telnyx outbound calls, and scheduled-task call delivery.
 

package/docs/configuration.md

@@ -68,7 +68,7 @@ Recording insight generation is controlled in app AI settings with `auto_recordi
 
 ## Official Integrations
 
-Official integrations use OAuth or provider-native account linking and expose structured tools to the agent. The built-in registry currently covers Google Workspace, Notion, Microsoft 365, Slack, Figma, and personal WhatsApp.
+Official integrations use OAuth or provider-native account linking and expose structured tools to the agent. The built-in registry currently covers Google Workspace, Notion, Microsoft 365, Slack, Figma, Home Assistant, and personal WhatsApp.
 
 All OAuth callbacks default to `PUBLIC_URL + /api/integrations/oauth/callback` unless you set a provider-specific redirect URI.
 
@@ -90,6 +90,10 @@ All OAuth callbacks default to `PUBLIC_URL + /api/integrations/oauth/callback` u
 | `FIGMA_OAUTH_CLIENT_ID` | Figma OAuth client ID |
 | `FIGMA_OAUTH_CLIENT_SECRET` | Figma OAuth client secret |
 | `FIGMA_OAUTH_REDIRECT_URI` | Optional Figma OAuth callback URL |
+| `HOME_ASSISTANT_BASE_URL` | Home Assistant base URL, for example `https://ha.example.com` |
+| `HOME_ASSISTANT_OAUTH_CLIENT_ID` | Home Assistant OAuth client ID |
+| `HOME_ASSISTANT_OAUTH_CLIENT_SECRET` | Home Assistant OAuth client secret |
+| `HOME_ASSISTANT_OAUTH_REDIRECT_URI` | Optional Home Assistant OAuth callback URL |
 
 ## Messaging
 

package/docs/integrations.md

@@ -13,6 +13,7 @@ The built-in registry includes:
 | Microsoft 365 | Outlook, Calendar, OneDrive, Teams, and Microsoft Graph requests |
 | Slack | Conversations, history, posting, search, user info, and Slack Web API requests |
 | Figma | Current user, files, nodes, rendered images, comments, and Figma REST requests |
+| Home Assistant | Entity/config reads, service calls, and Home Assistant REST API requests |
 
 OAuth app credentials are configured through server environment variables. Account connections are created in the Flutter UI under **Integrations**. Connected tools are exposed to the agent as structured tools, so prefer them over browser automation when they can do the job.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.2.1-beta.8",
+  "version": "2.3.1-beta.0",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"59aa584fdf100e6c78c785d8a5b565d1de4b48
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "807831779" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "714146073" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/services/integrations/env.js

@@ -56,6 +56,14 @@ function resolveMicrosoftOAuthConfig() {
   };
 }
 
+function resolveHomeAssistantOAuthConfig() {
+  const base = resolveOAuthConfig('HOME_ASSISTANT');
+  return {
+    ...base,
+    baseUrl: trimEnv('HOME_ASSISTANT_BASE_URL').replace(/\/$/, ''),
+  };
+}
+
 function describeEnvStatus(config, options = {}) {
   const label = String(options.label || 'This integration').trim() || 'This integration';
   if (config.configured) {
@@ -76,6 +84,7 @@ function describeEnvStatus(config, options = {}) {
 module.exports = {
   describeEnvStatus,
   resolveFigmaOAuthConfig,
+  resolveHomeAssistantOAuthConfig,
   resolveMicrosoftOAuthConfig,
   resolveNotionOAuthConfig,
   resolveOAuthConfig,

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

@@ -0,0 +1,350 @@
+'use strict';
+
+const crypto = require('crypto');
+const {
+  describeEnvStatus,
+  resolveHomeAssistantOAuthConfig,
+} = require('../env');
+const {
+  appendQuery,
+  createOAuthProvider,
+  fetchJson,
+} = require('../oauth_provider');
+
+const HOME_ASSISTANT_APPS = [
+  {
+    id: 'home_assistant',
+    label: 'Home Assistant',
+    description: 'Connect Home Assistant for entity state queries, service calls, and API access.',
+    scopes: ['homeassistant'],
+  },
+];
+
+const homeAssistantToolDefinitions = [
+  {
+    appId: 'home_assistant',
+    name: 'home_assistant_get_config',
+    access: 'read',
+    description: 'Get Home Assistant configuration details for the connected instance.',
+    parameters: { type: 'object', properties: {} },
+  },
+  {
+    appId: 'home_assistant',
+    name: 'home_assistant_list_states',
+    access: 'read',
+    description: 'List entity states from Home Assistant. Optional filters are applied client-side.',
+    parameters: {
+      type: 'object',
+      properties: {
+        domain: {
+          type: 'string',
+          description: 'Optional entity domain filter, for example light, climate, or switch.',
+        },
+        limit: {
+          type: 'number',
+          description: 'Optional max entities to return, default 100.',
+        },
+      },
+    },
+  },
+  {
+    appId: 'home_assistant',
+    name: 'home_assistant_get_state',
+    access: 'read',
+    description: 'Get state for a single Home Assistant entity by entity_id.',
+    parameters: {
+      type: 'object',
+      properties: {
+        entity_id: { type: 'string', description: 'Entity ID, for example light.living_room.' },
+      },
+      required: ['entity_id'],
+    },
+  },
+  {
+    appId: 'home_assistant',
+    name: 'home_assistant_call_service',
+    access: 'write',
+    description: 'Call a Home Assistant service such as light.turn_on or climate.set_temperature.',
+    parameters: {
+      type: 'object',
+      properties: {
+        domain: { type: 'string', description: 'Service domain, for example light, climate, or switch.' },
+        service: { type: 'string', description: 'Service name, for example turn_on, turn_off, or set_temperature.' },
+        service_data: { type: 'object', description: 'Optional Home Assistant service data payload.' },
+      },
+      required: ['domain', 'service'],
+    },
+  },
+  {
+    appId: 'home_assistant',
+    name: 'home_assistant_api_request',
+    access: 'dynamic_http_method',
+    description: 'Make an authenticated Home Assistant REST API request for advanced operations.',
+    parameters: {
+      type: 'object',
+      properties: {
+        method: { type: 'string', description: 'HTTP method: GET, POST, PUT, PATCH, or DELETE.' },
+        path: { type: 'string', description: 'API path under the configured instance, for example /api/history/period.' },
+        query: { type: 'object', description: 'Optional query parameters.' },
+        body: { type: 'object', description: 'Optional JSON body.' },
+      },
+      required: ['method', 'path'],
+    },
+  },
+];
+
+function requireText(value, label) {
+  const text = String(value || '').trim();
+  if (!text) throw new Error(`${label} is required.`);
+  return text;
+}
+
+function homeAssistantUrl(baseUrl, path, query) {
+  const normalizedBase = String(baseUrl || '').trim().replace(/\/$/, '');
+  if (!normalizedBase) {
+    throw new Error('HOME_ASSISTANT_BASE_URL is required.');
+  }
+  const url = new URL(
+    String(path || '').startsWith('http')
+      ? String(path)
+      : `${normalizedBase}${String(path || '').startsWith('/') ? '' : '/'}${path}`,
+  );
+  if (new URL(normalizedBase).origin !== url.origin) {
+    throw new Error('Home Assistant request URL must stay on HOME_ASSISTANT_BASE_URL origin.');
+  }
+  for (const [key, value] of Object.entries(query || {})) {
+    if (value !== undefined && value !== null) url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+
+async function homeAssistantRequest(credentials, options = {}) {
+  const config = resolveHomeAssistantOAuthConfig();
+  const accessToken = String(credentials?.access_token || '').trim();
+  if (!accessToken) {
+    throw new Error('Home Assistant access token is missing. Reconnect this integration account.');
+  }
+  const method = String(options.method || 'GET').toUpperCase();
+  return fetchJson(
+    homeAssistantUrl(config.baseUrl, options.path, options.query),
+    {
+      method,
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+      ...(options.body === undefined ? {} : { json: options.body }),
+    },
+    { serviceName: 'Home Assistant' },
+  );
+}
+
+async function executeHomeAssistantTool(toolName, args, { credentials }) {
+  switch (toolName) {
+    case 'home_assistant_get_config':
+      return {
+        result: await homeAssistantRequest(credentials, { path: '/api/config' }),
+      };
+    case 'home_assistant_list_states': {
+      const states = await homeAssistantRequest(credentials, { path: '/api/states' });
+      const domain = String(args.domain || '').trim().toLowerCase();
+      const limit = Math.max(1, Math.min(Number(args.limit) || 100, 500));
+      const filtered = Array.isArray(states)
+        ? states.filter((item) => {
+            if (!domain) return true;
+            const entityId = String(item?.entity_id || '').toLowerCase();
+            return entityId.startsWith(`${domain}.`);
+          })
+        : [];
+      return {
+        result: filtered.slice(0, limit),
+      };
+    }
+    case 'home_assistant_get_state':
+      return {
+        result: await homeAssistantRequest(credentials, {
+          path: `/api/states/${encodeURIComponent(requireText(args.entity_id, 'entity_id'))}`,
+        }),
+      };
+    case 'home_assistant_call_service':
+      return {
+        result: await homeAssistantRequest(credentials, {
+          method: 'POST',
+          path: `/api/services/${encodeURIComponent(requireText(args.domain, 'domain'))}/${encodeURIComponent(requireText(args.service, 'service'))}`,
+          body: args.service_data || {},
+        }),
+      };
+    case 'home_assistant_api_request':
+      return {
+        result: await homeAssistantRequest(credentials, {
+          method: args.method,
+          path: requireText(args.path, 'path'),
+          query: args.query,
+          body: args.body,
+        }),
+      };
+    default:
+      return null;
+  }
+}
+
+function resolveHomeAssistantEnvStatus() {
+  const config = resolveHomeAssistantOAuthConfig();
+  const missing = config.missing.slice();
+  if (!config.baseUrl) {
+    missing.push('HOME_ASSISTANT_BASE_URL');
+  }
+  return describeEnvStatus(
+    {
+      configured: missing.length === 0,
+      missing,
+    },
+    { label: 'Home Assistant' },
+  );
+}
+
+function normalizeCurrentUser(currentUser) {
+  const payload = currentUser && typeof currentUser === 'object' ? currentUser : {};
+  return {
+    id: payload.id || null,
+    name: payload.name || null,
+    username: payload.username || null,
+    email: payload.email || null,
+    isOwner: Boolean(payload.is_owner),
+  };
+}
+
+function stableAccountEmailLikeIdentifier(user, config) {
+  const normalized = normalizeCurrentUser(user);
+  const preferred = [normalized.email, normalized.username, normalized.id, normalized.name]
+    .map((value) => String(value || '').trim())
+    .find(Boolean);
+  if (preferred) {
+    return preferred;
+  }
+  const host = new URL(config.baseUrl).host;
+  return `homeassistant@${host}`;
+}
+
+async function fetchCurrentUser(token) {
+  const config = resolveHomeAssistantOAuthConfig();
+  return fetchJson(
+    homeAssistantUrl(config.baseUrl, '/api/auth/current_user'),
+    {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    },
+    { serviceName: 'Home Assistant' },
+  ).catch(() => null);
+}
+
+function createHomeAssistantProvider() {
+  return createOAuthProvider({
+    key: 'home_assistant',
+    label: 'Home Assistant',
+    description:
+      'Official Home Assistant account connections for entity state reads, service control, and automation support.',
+    icon: 'home_assistant',
+    apps: HOME_ASSISTANT_APPS,
+    toolDefinitions: homeAssistantToolDefinitions,
+    connectPrompt:
+      'Connect your Home Assistant account to let the agent read entity states and control services with structured tools.',
+    getEnvStatus() {
+      return resolveHomeAssistantEnvStatus();
+    },
+    async beginOAuth({ state, codeVerifier, app }) {
+      const config = resolveHomeAssistantOAuthConfig();
+      const codeChallenge = String(codeChallengeForVerifier(codeVerifier));
+      return {
+        url: appendQuery(homeAssistantUrl(config.baseUrl, '/auth/authorize'), {
+          response_type: 'code',
+          client_id: config.clientId,
+          redirect_uri: config.redirectUri,
+          state,
+          scope: app.scopes.join(' '),
+          code_challenge: codeChallenge,
+          code_challenge_method: 'S256',
+        }),
+        appId: app.id,
+      };
+    },
+    async finishOAuth({ code, codeVerifier, app }) {
+      const config = resolveHomeAssistantOAuthConfig();
+      const token = await fetchJson(
+        homeAssistantUrl(config.baseUrl, '/auth/token'),
+        {
+          method: 'POST',
+          form: {
+            grant_type: 'authorization_code',
+            client_id: config.clientId,
+            client_secret: config.clientSecret,
+            code,
+            code_verifier: codeVerifier,
+            redirect_uri: config.redirectUri,
+          },
+        },
+        { serviceName: 'Home Assistant' },
+      );
+
+      const accessToken = String(token?.access_token || '').trim();
+      if (!accessToken) {
+        throw new Error('Home Assistant OAuth did not return an access token.');
+      }
+
+      const refreshToken = String(token?.refresh_token || '').trim();
+      if (!refreshToken) {
+        throw new Error('Home Assistant OAuth did not return a refresh token.');
+      }
+
+      const currentUser = await fetchCurrentUser(accessToken);
+      const normalizedUser = normalizeCurrentUser(currentUser);
+      const accountEmail = stableAccountEmailLikeIdentifier(normalizedUser, config);
+
+      return {
+        appId: app.id,
+        accountEmail,
+        credentials: {
+          access_token: accessToken,
+          refresh_token: refreshToken,
+          token_type: token?.token_type || 'Bearer',
+          expires_in: token?.expires_in || null,
+          scope: token?.scope || app.scopes.join(' '),
+        },
+        scopes: Array.isArray(token?.scope)
+          ? token.scope
+          : String(token?.scope || app.scopes.join(' '))
+              .split(/\s+/)
+              .map((scope) => scope.trim())
+              .filter(Boolean),
+        metadata: {
+          homeAssistantUrl: config.baseUrl,
+          userId: normalizedUser.id,
+          name: normalizedUser.name,
+          username: normalizedUser.username,
+          email: normalizedUser.email,
+          isOwner: normalizedUser.isOwner,
+        },
+      };
+    },
+    executeTool: executeHomeAssistantTool,
+  });
+}
+
+function base64UrlSha256(value) {
+  return crypto
+    .createHash('sha256')
+    .update(String(value || ''))
+    .digest('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+function codeChallengeForVerifier(codeVerifier) {
+  return base64UrlSha256(String(codeVerifier || ''));
+}
+
+module.exports = {
+  createHomeAssistantProvider,
+};

package/server/services/integrations/registry.js

@@ -2,6 +2,7 @@
 
 const { createFigmaProvider } = require('./figma/provider');
 const { createGoogleWorkspaceProvider } = require('./google/provider');
+const { createHomeAssistantProvider } = require('./home_assistant/provider');
 const { createMicrosoftProvider } = require('./microsoft/provider');
 const { createNotionProvider } = require('./notion/provider');
 const { createSlackProvider } = require('./slack/provider');
@@ -14,6 +15,7 @@ function createIntegrationRegistry(options = {}) {
     createMicrosoftProvider(),
     createSlackProvider(),
     createFigmaProvider(),
+    createHomeAssistantProvider(),
     createWhatsAppPersonalProvider(options),
   ];
   const byKey = new Map(providers.map((provider) => [provider.key, provider]));