neoagent 2.4.1-beta.28 → 2.4.1-beta.30

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

@@ -0,0 +1,98 @@
+'use strict';
+
+const { getConnectionAccessMode } = require('../access');
+const {
+  HOME_ASSISTANT_APP,
+  HOME_ASSISTANT_TOOL_DEFINITIONS,
+} = require('./constants');
+
+function summarizeAccountRow(row, envStatus) {
+  if (!envStatus.configured) {
+    return {
+      id: row?.id || null,
+      status: 'env_not_configured',
+      connected: false,
+      accountEmail: row?.account_email || null,
+      lastConnectedAt: row?.last_connected_at || null,
+      accessMode: 'read_write',
+    };
+  }
+
+  if (!row) {
+    return {
+      id: null,
+      status: 'not_connected',
+      connected: false,
+      accountEmail: null,
+      lastConnectedAt: null,
+      accessMode: 'read_write',
+    };
+  }
+
+  return {
+    id: row.id || null,
+    status: row.status || 'not_connected',
+    connected: row.status === 'connected',
+    accountEmail: row.account_email || null,
+    lastConnectedAt: row.last_connected_at || null,
+    accessMode: getConnectionAccessMode(row),
+  };
+}
+
+function summarizeAppConnection(app, connectionRows, envStatus) {
+  const accounts = (Array.isArray(connectionRows) ? connectionRows : [])
+    .slice()
+    .sort((left, right) => String(right.updated_at || '').localeCompare(String(left.updated_at || '')))
+    .map((row) => summarizeAccountRow(row, envStatus));
+  const connectedAccounts = accounts.filter((account) => account.connected);
+  return {
+    id: app.id,
+    label: app.label,
+    description: app.description,
+    accounts,
+    connection: {
+      status: !envStatus.configured ? 'env_not_configured' : connectedAccounts.length > 0 ? 'connected' : 'not_connected',
+      connected: connectedAccounts.length > 0,
+      accountCount: connectedAccounts.length,
+      accountEmail: connectedAccounts.length === 1 ? connectedAccounts[0].accountEmail : null,
+      lastConnectedAt: connectedAccounts.map((account) => account.lastConnectedAt).filter(Boolean).sort().reverse()[0] || null,
+    },
+    availableToolCount: envStatus.configured && connectedAccounts.length > 0 ? HOME_ASSISTANT_TOOL_DEFINITIONS.length : 0,
+  };
+}
+
+function buildHomeAssistantSnapshot(provider, connectionRows, context = {}) {
+  const env = provider.getEnvStatus(context);
+  const byApp = new Map();
+  for (const row of Array.isArray(connectionRows) ? connectionRows : []) {
+    const appId = String(row.app_key || '').trim();
+    if (!byApp.has(appId)) byApp.set(appId, []);
+    byApp.get(appId).push(row);
+  }
+  const appSnapshots = [HOME_ASSISTANT_APP].map((app) => summarizeAppConnection(app, byApp.get(app.id) || [], env));
+  const connectedAccounts = appSnapshots.flatMap((app) => app.accounts.filter((account) => account.connected));
+  return {
+    id: provider.key,
+    label: provider.label,
+    description: provider.description,
+    icon: provider.icon,
+    apps: appSnapshots,
+    env,
+    connection: {
+      status: !env.configured ? 'env_not_configured' : connectedAccounts.length > 0 ? 'connected' : 'not_connected',
+      connected: connectedAccounts.length > 0,
+      accountEmail: connectedAccounts.length === 1 ? connectedAccounts[0].accountEmail : null,
+      accountCount: connectedAccounts.length,
+      appCount: appSnapshots.filter((app) => app.connection.connected).length,
+      lastConnectedAt: connectedAccounts.map((account) => account.lastConnectedAt).filter(Boolean).sort().reverse()[0] || null,
+    },
+    availableToolCount: appSnapshots.reduce((total, app) => total + app.availableToolCount, 0),
+    connectPrompt: provider.connectPrompt,
+    supportsMultipleAccounts: provider.supportsMultipleAccounts,
+    connectionMethod: provider.connectionMethod,
+  };
+}
+
+module.exports = {
+  buildHomeAssistantSnapshot,
+};

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

@@ -0,0 +1,101 @@
+'use strict';
+
+const { decryptValue } = require('../secrets');
+const { homeAssistantRequest, normalizeHomeAssistantBaseUrl, requireText, trimText } = require('./network');
+
+async function fetchHomeAssistantConfig(credentials) {
+  return homeAssistantRequest(credentials, { method: 'GET', path: '/api/config' });
+}
+
+function parseCredentials(connection) {
+  try {
+    return JSON.parse(decryptValue(connection?.credentials_json || '{}') || '{}');
+  } catch {
+    return {};
+  }
+}
+
+function connectionCredentials(connection) {
+  const credentials = parseCredentials(connection);
+  return {
+    baseUrl: normalizeHomeAssistantBaseUrl(credentials.baseUrl),
+    token: requireText(credentials.token, 'Home Assistant token'),
+  };
+}
+
+function filterStates(states, args = {}) {
+  const domain = trimText(args.entity_domain).toLowerCase();
+  const limit = Math.max(1, Math.min(Number(args.limit) || 100, 500));
+  const filtered = Array.isArray(states)
+    ? states.filter((state) => !domain || String(state?.entity_id || '').toLowerCase().startsWith(`${domain}.`))
+    : [];
+  return filtered.slice(0, limit).map((state) => ({
+    entity_id: state.entity_id || null,
+    state: state.state || null,
+    attributes: state.attributes || {},
+    last_changed: state.last_changed || null,
+    last_updated: state.last_updated || null,
+  }));
+}
+
+function validateServiceSegment(value, label) {
+  const text = requireText(value, label).toLowerCase();
+  if (!/^[a-z0-9_]+$/.test(text)) {
+    throw new Error(`${label} must contain only lowercase letters, numbers, and underscores.`);
+  }
+  return text;
+}
+
+async function executeHomeAssistantTool(toolName, args, connection) {
+  const credentials = connectionCredentials(connection);
+
+  switch (toolName) {
+    case 'home_assistant_get_config':
+      return { result: await fetchHomeAssistantConfig(credentials) };
+    case 'home_assistant_list_states':
+      return {
+        result: filterStates(
+          await homeAssistantRequest(credentials, { method: 'GET', path: '/api/states' }),
+          args,
+        ),
+      };
+    case 'home_assistant_get_state':
+      return {
+        result: await homeAssistantRequest(credentials, {
+          method: 'GET',
+          path: `/api/states/${encodeURIComponent(requireText(args.entity_id, 'entity_id'))}`,
+        }),
+      };
+    case 'home_assistant_call_service': {
+      const domain = validateServiceSegment(args.domain, 'domain');
+      const service = validateServiceSegment(args.service, 'service');
+      const serviceData = args.service_data && typeof args.service_data === 'object' && !Array.isArray(args.service_data)
+        ? args.service_data
+        : {};
+      return {
+        result: await homeAssistantRequest(credentials, {
+          method: 'POST',
+          path: `/api/services/${domain}/${service}`,
+          body: serviceData,
+        }),
+      };
+    }
+    case 'home_assistant_api_request':
+      return {
+        result: await homeAssistantRequest(credentials, {
+          method: args.method,
+          path: requireText(args.path, 'path'),
+          query: args.query && typeof args.query === 'object' ? args.query : {},
+          body: args.body && typeof args.body === 'object' ? args.body : undefined,
+        }),
+      };
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  executeHomeAssistantTool,
+  fetchHomeAssistantConfig,
+  parseCredentials,
+};

package/server/services/integrations/registry.js

@@ -3,6 +3,7 @@
 const { createFigmaProvider } = require('./figma/provider');
 const { createGoogleWorkspaceProvider } = require('./google/provider');
 const { createGithubProvider } = require('./github/provider');
+const { createHomeAssistantProvider } = require('./home_assistant/provider');
 const { createTrelloProvider } = require('./trello/provider');
 const { createMicrosoftProvider } = require('./microsoft/provider');
 const { createNotionProvider } = require('./notion/provider');
@@ -22,6 +23,7 @@ function createIntegrationRegistry(options = {}) {
     createTrelloProvider(),
     createWeatherProvider(),
     createSpotifyProvider(),
+    createHomeAssistantProvider(),
     createWhatsAppPersonalProvider(options),
   ];
   const byKey = new Map(providers.map((provider) => [provider.key, provider]));

package/server/services/workspace/manager.js

@@ -80,9 +80,125 @@ class WorkspaceManager {
     if (relative.startsWith('..') || path.isAbsolute(relative)) {
       throw new Error(`${label} is outside the per-user workspace.`);
     }
+    this._assertResolvedPathInsideRoot(root, absolute, label);
     return absolute;
   }
 
+  _assertResolvedPathInsideRoot(root, absolute, label = 'path') {
+    const realRoot = fs.realpathSync.native(root);
+    let targetToCheck = absolute;
+    while (!fs.existsSync(targetToCheck)) {
+      const parent = path.dirname(targetToCheck);
+      if (parent === targetToCheck) break;
+      targetToCheck = path.dirname(targetToCheck);
+    }
+    const realTarget = fs.realpathSync.native(targetToCheck);
+    const relative = path.relative(realRoot, realTarget);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+      throw new Error(`${label} is outside the per-user workspace.`);
+    }
+  }
+
+  _toWorkspaceRelative(root, absolute) {
+    const relative = path.relative(root, absolute);
+    return relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+      ? relative.split(path.sep).join('/')
+      : '';
+  }
+
+  listExplorerDirectory(userId, options = {}) {
+    const root = this._ensureWorkspaceRootSync(userId);
+    const dirPath = this.resolvePath(userId, options.path || '.', 'path');
+    let stats;
+    try {
+      stats = fs.statSync(dirPath);
+    } catch (err) {
+      return { path: this._toWorkspaceRelative(root, dirPath), entries: [], error: err.message };
+    }
+    if (!stats.isDirectory()) {
+      return { path: this._toWorkspaceRelative(root, dirPath), entries: [], error: 'Path is not a directory.' };
+    }
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true }).flatMap((entry) => {
+      const fullPath = path.join(dirPath, entry.name);
+      let entryStats;
+      try {
+        entryStats = fs.lstatSync(fullPath);
+        if (entryStats.isSymbolicLink()) return [];
+        entryStats = fs.statSync(fullPath);
+      } catch {
+        return [];
+      }
+      if (!entryStats.isDirectory() && !entryStats.isFile()) return [];
+      return [{
+        name: entry.name,
+        type: entryStats.isDirectory() ? 'directory' : 'file',
+        path: this._toWorkspaceRelative(root, fullPath),
+        size: entryStats.size,
+        mtime: entryStats.mtime.toISOString(),
+      }];
+    }).sort((a, b) => {
+      if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return {
+      path: this._toWorkspaceRelative(root, dirPath),
+      parentPath: this._toWorkspaceRelative(root, path.dirname(dirPath)),
+      entries,
+    };
+  }
+
+  readExplorerFile(userId, options = {}) {
+    const root = this._ensureWorkspaceRootSync(userId);
+    const filePath = this.resolvePath(userId, options.path || '', 'path');
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile()) {
+      throw new Error('Path is not a file.');
+    }
+    const maxBytes = Number(options.maxBytes || 1024 * 1024);
+    if (stats.size > maxBytes) {
+      const error = new Error(`File is too large to edit in the browser (${stats.size} bytes).`);
+      error.code = 'WORKSPACE_FILE_TOO_LARGE';
+      throw error;
+    }
+    return {
+      path: this._toWorkspaceRelative(root, filePath),
+      name: path.basename(filePath),
+      content: fs.readFileSync(filePath, 'utf8'),
+      size: stats.size,
+      mtime: stats.mtime.toISOString(),
+    };
+  }
+
+  writeExplorerFile(userId, options = {}) {
+    const root = this._ensureWorkspaceRootSync(userId);
+    const filePath = this.resolvePath(userId, options.path || '', 'path');
+    const content = String(options.content ?? '');
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf8');
+    const stats = fs.statSync(filePath);
+    return {
+      success: true,
+      path: this._toWorkspaceRelative(root, filePath),
+      size: stats.size,
+      mtime: stats.mtime.toISOString(),
+    };
+  }
+
+  getExplorerDownload(userId, options = {}) {
+    const root = this._ensureWorkspaceRootSync(userId);
+    const filePath = this.resolvePath(userId, options.path || '', 'path');
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile()) {
+      throw new Error('Path is not a file.');
+    }
+    return {
+      root,
+      absolutePath: filePath,
+      relativePath: this._toWorkspaceRelative(root, filePath),
+      filename: path.basename(filePath),
+    };
+  }
+
   readFile(userId, options = {}) {
     let filePath;
     try {