neoagent 1.4.3 → 1.4.5

package/lib/manager.js

@@ -438,6 +438,12 @@ async function cmdStatus() {
     logWarn(`not reachable on port ${port}`);
   }
 
+  const gitVersion = runQuiet('git', ['describe', '--tags', '--always', '--dirty']);
+  if (gitVersion.status === 0) {
+    console.log(`  version ${gitVersion.stdout.trim().replace(/^v/, '')}`);
+    return;
+  }
+
   const gitSha = runQuiet('git', ['rev-parse', '--short', 'HEAD']);
   if (gitSha.status === 0) {
     console.log(`  version ${gitSha.stdout.trim()}`);

package/package.json

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

package/server/db/database.js

@@ -228,6 +228,47 @@ db.exec(`
   CREATE INDEX IF NOT EXISTS idx_protocols_user ON protocols(user_id);
 
   CREATE INDEX IF NOT EXISTS idx_core_memory_user ON core_memory(user_id, key);
+
+  CREATE TABLE IF NOT EXISTS health_sync_runs (
+    id TEXT PRIMARY KEY,
+    user_id INTEGER NOT NULL,
+    source TEXT NOT NULL,
+    provider TEXT,
+    sync_window_start TEXT,
+    sync_window_end TEXT,
+    record_count INTEGER DEFAULT 0,
+    summary_json TEXT,
+    payload_json TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+  );
+
+  CREATE TABLE IF NOT EXISTS health_metric_samples (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL,
+    sync_run_id TEXT NOT NULL,
+    metric_type TEXT NOT NULL,
+    record_id TEXT NOT NULL,
+    start_time TEXT,
+    end_time TEXT,
+    recorded_at TEXT,
+    numeric_value REAL,
+    text_value TEXT,
+    unit TEXT,
+    source_app_id TEXT,
+    source_device TEXT,
+    last_modified_time TEXT,
+    payload_json TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    FOREIGN KEY (sync_run_id) REFERENCES health_sync_runs(id) ON DELETE CASCADE,
+    UNIQUE(user_id, metric_type, record_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_health_sync_runs_user ON health_sync_runs(user_id, created_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_health_metric_samples_user ON health_metric_samples(user_id, metric_type, updated_at DESC);
+  CREATE INDEX IF NOT EXISTS idx_health_metric_samples_time ON health_metric_samples(user_id, start_time DESC, end_time DESC);
 `);
 
 try {

package/server/index.js

@@ -107,6 +107,7 @@ app.use('/api/store', require('./routes/store'));
 app.use('/api/memory', require('./routes/memory'));
 app.use('/api/scheduler', require('./routes/scheduler'));
 app.use('/api/browser', require('./routes/browser'));
+app.use('/api/mobile/health', require('./routes/mobile-health'));
 
 // ── Telnyx voice webhook ──
 setupTelnyxWebhook(app);
@@ -155,9 +156,15 @@ app.get('/api/health', requireAuth, (req, res) => {
 });
 
 app.get('/api/version', requireAuth, (req, res) => {
+  let version = packageJson.version;
   let gitSha = null;
   try {
     const { execSync } = require('child_process');
+    version = execSync('git describe --tags --always --dirty', {
+      cwd: APP_DIR,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim().replace(/^v/, '') || packageJson.version;
     gitSha = execSync('git rev-parse --short HEAD', {
       cwd: APP_DIR,
       encoding: 'utf8',
@@ -169,7 +176,8 @@ app.get('/api/version', requireAuth, (req, res) => {
 
   res.json({
     name: packageJson.name,
-    version: packageJson.version,
+    version,
+    packageVersion: packageJson.version,
     gitSha
   });
 });

package/server/public/js/app.js

@@ -1823,7 +1823,7 @@ $("#settingsBtn").addEventListener("click", async () => {
 
     try {
       const backendVersion = await api("/version");
-      backendVersionLabel = `${backendVersion?.version || "unknown"}${backendVersion?.gitSha ? ` (${backendVersion.gitSha})` : ""}`;
+      backendVersionLabel = backendVersion?.version || "unknown";
       const vEl = $("#settingsAppVersion");
       if (vEl && backendVersionLabel !== "unknown") {
         vEl.textContent = `v${backendVersionLabel}`;

package/server/routes/mobile-health.js

@@ -0,0 +1,28 @@
+const express = require('express');
+const router = express.Router();
+const { requireAuth } = require('../middleware/auth');
+const { sanitizeError } = require('../utils/security');
+const { getHealthSyncStatus, ingestHealthSync } = require('../services/health/ingestion');
+
+router.use(requireAuth);
+
+router.get('/status', (req, res) => {
+  try {
+    res.json(getHealthSyncStatus(req.session.userId));
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
+router.post('/sync', (req, res) => {
+  try {
+    const result = ingestHealthSync(req.session.userId, req.body);
+    res.status(201).json({ success: true, ...result });
+  } catch (err) {
+    const message = sanitizeError(err);
+    const status = /payload|Missing user/i.test(message) ? 400 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+module.exports = router;

package/server/services/ai/providers/google.js

@@ -81,7 +81,33 @@ class GoogleProvider extends BaseProvider {
       });
     }
 
-    return { systemInstruction, history };
+    const normalizedHistory = [];
+    let currentRole = null;
+    let currentParts = [];
+
+    for (const msg of history) {
+      if (msg.role === currentRole) {
+        currentParts.push(...msg.parts);
+      } else {
+        if (currentRole) {
+          normalizedHistory.push({ role: currentRole, parts: currentParts });
+        }
+        currentRole = msg.role;
+        currentParts = [...msg.parts];
+      }
+    }
+    if (currentRole) {
+      normalizedHistory.push({ role: currentRole, parts: currentParts });
+    }
+
+    if (normalizedHistory.length > 0 && normalizedHistory[0].role !== 'user') {
+      normalizedHistory.unshift({
+        role: 'user',
+        parts: [{ text: '[Conversation Resumed]' }]
+      });
+    }
+
+    return { systemInstruction, history: normalizedHistory };
   }
 
   async chat(messages, tools = [], options = {}) {

package/server/services/health/ingestion.js

@@ -0,0 +1,175 @@
+const crypto = require('crypto');
+const db = require('../../db/database');
+const { v4: uuidv4 } = require('uuid');
+
+function parseIsoOrNull(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function asJson(value) {
+  return JSON.stringify(value == null ? null : value);
+}
+
+function asText(value) {
+  if (value == null) return null;
+  const text = String(value).trim();
+  return text.length ? text : null;
+}
+
+function buildFallbackRecordId(metricType, record) {
+  const hash = crypto.createHash('sha1');
+  hash.update(metricType || '');
+  hash.update('\n');
+  hash.update(asJson(record));
+  return hash.digest('hex');
+}
+
+function normalizeRecord(record = {}) {
+  const metricType = asText(record.metricType || record.type);
+  if (!metricType) return null;
+
+  const payload = record.payload && typeof record.payload === 'object'
+    ? record.payload
+    : {};
+
+  return {
+    metricType,
+    recordId: asText(record.recordId || payload.recordId) || buildFallbackRecordId(metricType, record),
+    startTime: parseIsoOrNull(record.startTime || payload.startTime),
+    endTime: parseIsoOrNull(record.endTime || payload.endTime),
+    recordedAt: parseIsoOrNull(record.recordedAt || payload.recordedAt || record.endTime || record.startTime),
+    numericValue: Number.isFinite(Number(record.numericValue)) ? Number(record.numericValue) : null,
+    textValue: asText(record.textValue),
+    unit: asText(record.unit),
+    sourceAppId: asText(record.sourceAppId || payload.sourceAppId),
+    sourceDevice: asText(record.sourceDevice || payload.sourceDevice),
+    lastModifiedTime: parseIsoOrNull(record.lastModifiedTime || payload.lastModifiedTime),
+    payloadJson: asJson(payload),
+  };
+}
+
+const insertRun = db.prepare(`
+  INSERT INTO health_sync_runs (
+    id, user_id, source, provider, sync_window_start, sync_window_end,
+    record_count, summary_json, payload_json
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+`);
+
+const upsertSample = db.prepare(`
+  INSERT INTO health_metric_samples (
+    user_id, sync_run_id, metric_type, record_id, start_time, end_time, recorded_at,
+    numeric_value, text_value, unit, source_app_id, source_device, last_modified_time, payload_json
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(user_id, metric_type, record_id) DO UPDATE SET
+    sync_run_id = excluded.sync_run_id,
+    start_time = excluded.start_time,
+    end_time = excluded.end_time,
+    recorded_at = excluded.recorded_at,
+    numeric_value = excluded.numeric_value,
+    text_value = excluded.text_value,
+    unit = excluded.unit,
+    source_app_id = excluded.source_app_id,
+    source_device = excluded.source_device,
+    last_modified_time = excluded.last_modified_time,
+    payload_json = excluded.payload_json,
+    updated_at = datetime('now')
+`);
+
+const ingestHealthSyncTx = db.transaction((userId, body) => {
+  const runId = uuidv4();
+  const source = asText(body.source) || 'android-health-connect';
+  const provider = asText(body.provider);
+  const windowStart = parseIsoOrNull(body.windowStart);
+  const windowEnd = parseIsoOrNull(body.windowEnd);
+  const records = Array.isArray(body.records)
+    ? body.records.map(normalizeRecord).filter(Boolean)
+    : [];
+
+  insertRun.run(
+    runId,
+    userId,
+    source,
+    provider,
+    windowStart,
+    windowEnd,
+    records.length,
+    asJson(body.summary || {}),
+    asJson(body),
+  );
+
+  for (const record of records) {
+    upsertSample.run(
+      userId,
+      runId,
+      record.metricType,
+      record.recordId,
+      record.startTime,
+      record.endTime,
+      record.recordedAt,
+      record.numericValue,
+      record.textValue,
+      record.unit,
+      record.sourceAppId,
+      record.sourceDevice,
+      record.lastModifiedTime,
+      record.payloadJson,
+    );
+  }
+
+  return {
+    runId,
+    source,
+    provider,
+    windowStart,
+    windowEnd,
+    recordCount: records.length,
+    acceptedMetrics: [...new Set(records.map((record) => record.metricType))],
+  };
+});
+
+function ingestHealthSync(userId, body = {}) {
+  if (!userId) throw new Error('Missing user');
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    throw new Error('Health sync payload must be a JSON object');
+  }
+  return ingestHealthSyncTx(userId, body);
+}
+
+function getHealthSyncStatus(userId) {
+  const lastRun = db.prepare(`
+    SELECT id, source, provider, sync_window_start, sync_window_end, record_count, summary_json, created_at
+    FROM health_sync_runs
+    WHERE user_id = ?
+    ORDER BY created_at DESC
+    LIMIT 1
+  `).get(userId);
+
+  const metrics = db.prepare(`
+    SELECT metric_type, COUNT(*) AS sample_count, MAX(COALESCE(end_time, recorded_at, start_time)) AS last_seen_at
+    FROM health_metric_samples
+    WHERE user_id = ?
+    GROUP BY metric_type
+    ORDER BY metric_type ASC
+  `).all(userId);
+
+  return {
+    lastRun: lastRun ? {
+      ...lastRun,
+      summary: (() => {
+        try { return JSON.parse(lastRun.summary_json || '{}'); } catch { return {}; }
+      })(),
+    } : null,
+    metrics: metrics.map((metric) => ({
+      metricType: metric.metric_type,
+      sampleCount: Number(metric.sample_count || 0),
+      lastSeenAt: metric.last_seen_at || null,
+    })),
+  };
+}
+
+module.exports = {
+  getHealthSyncStatus,
+  ingestHealthSync,
+};