@cgh567/agent 2.4.2 → 2.4.4

package/daemon/routes/dashboard.js

@@ -29,16 +29,28 @@ async function handleGetCosts(req, res, ctx) {
 
   const url = new URL(req.url, 'http://localhost');
   const groupBy = url.searchParams.get('groupBy');
+  // G-01: date range filtering — ?from=ISO&to=ISO
+  const fromDate = url.searchParams.get('from') || null;
+  const toDate = url.searchParams.get('to') || null;
 
    try {
     if (groupBy && ['provider', 'model', 'agent'].includes(groupBy)) {
       const field = groupBy === 'agent' ? 'agentId' : groupBy;
-      const result = await mgQuery(
-        `MATCH (c:CostEvent {companyId: $cid})
-         RETURN c.${field} AS groupKey, sum(coalesce(c.costCents, c.amount * 100, 0)) / 100.0 AS total, count(c) AS count
-         ORDER BY total DESC`,
-        { cid: ctx.cid }
-      );
+      let groupCypher = `MATCH (c:CostEvent {companyId: $cid})`;
+      const groupParams = { cid: ctx.cid };
+      if (fromDate && toDate) {
+        groupCypher += ' WHERE c.createdAt >= $from AND c.createdAt <= $to';
+        groupParams.from = fromDate;
+        groupParams.to = toDate;
+      } else if (fromDate) {
+        groupCypher += ' WHERE c.createdAt >= $from';
+        groupParams.from = fromDate;
+      } else if (toDate) {
+        groupCypher += ' WHERE c.createdAt <= $to';
+        groupParams.to = toDate;
+      }
+      groupCypher += ` RETURN c.${field} AS groupKey, sum(coalesce(c.costCents, c.amount * 100, 0)) / 100.0 AS total, count(c) AS count ORDER BY total DESC`;
+      const result = await mgQuery(groupCypher, groupParams);
       const rows = (result?.rows ?? []);
       const groups = rows.map(r => ({ [groupBy]: r[0], total: r[1], count: r[2] }));
       res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -46,8 +58,20 @@ async function handleGetCosts(req, res, ctx) {
       return;
     }
 
-    const result = await mgQuery(
-      `MATCH (c:CostEvent {companyId: $cid})
+    let listCypher = `MATCH (c:CostEvent {companyId: $cid})`;
+    const listParams = { cid: ctx.cid, limit: 100 };
+    if (fromDate && toDate) {
+      listCypher += ' WHERE c.createdAt >= $from AND c.createdAt <= $to';
+      listParams.from = fromDate;
+      listParams.to = toDate;
+    } else if (fromDate) {
+      listCypher += ' WHERE c.createdAt >= $from';
+      listParams.from = fromDate;
+    } else if (toDate) {
+      listCypher += ' WHERE c.createdAt <= $to';
+      listParams.to = toDate;
+    }
+    listCypher += `
        RETURN c.id AS id, c.provider AS provider, c.model AS model,
               c.agentId AS agentId,
               coalesce(c.costCents, c.amount * 100, 0) / 100.0 AS amount,
@@ -55,9 +79,8 @@ async function handleGetCosts(req, res, ctx) {
               c.inputTokens AS inputTokens, c.outputTokens AS outputTokens,
               c.createdAt AS createdAt
        ORDER BY c.createdAt DESC
-       LIMIT toInteger($limit)`,
-      { cid: ctx.cid, limit: 100 }
-    );
+       LIMIT toInteger($limit)`;
+    const result = await mgQuery(listCypher, listParams);
     const rows = (result?.rows ?? []);
     const keys = ['id', 'provider', 'model', 'agentId', 'amount', 'biller', 'inputTokens', 'outputTokens', 'createdAt'];
     const events = rows.map(r => {
@@ -78,14 +101,31 @@ async function handleGetCosts(req, res, ctx) {
  * Returns all budget policies with current spend percentage.
  */
 async function handleGetBudgetStatus(req, res, ctx) {
+  // C-1 fix: filter by agentId when provided — prevents one agent seeing another's budget policy
+  const url = new URL(req.url, 'http://localhost');
+  const agentIdFilter = url.searchParams.get('agentId') || null;
+  // M-3 fix: guard against Memgraph unavailability
+  if (!ctx.mgQuery) {
+    res.writeHead(503, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Memgraph not connected', policies: [] }));
+    return;
+  }
   try {
-    const result = await ctx.mgQuery(
-      `MATCH (bp:BudgetPolicy {companyId: $cid})
+    let cypher, params;
+    if (agentIdFilter) {
+      cypher = `MATCH (bp:BudgetPolicy {companyId: $cid, agentId: $agentId})
+       RETURN bp.id AS id, bp.scope AS scope, bp.agentId AS agentId,
+              bp.limitCents AS limitCents, bp.spentCents AS spentCents,
+              bp.warnPercent AS warnPercent`;
+      params = { cid: ctx.cid, agentId: agentIdFilter };
+    } else {
+      cypher = `MATCH (bp:BudgetPolicy {companyId: $cid})
        RETURN bp.id AS id, bp.scope AS scope, bp.agentId AS agentId,
               bp.limitCents AS limitCents, bp.spentCents AS spentCents,
-              bp.warnPercent AS warnPercent`,
-      { cid: ctx.cid }
-    );
+              bp.warnPercent AS warnPercent`;
+      params = { cid: ctx.cid };
+    }
+    const result = await ctx.mgQuery(cypher, params);
 
     const policies = (result?.rows ?? []).map(([id, scope, agentId, limitCents, spentCents, warnPercent]) => {
       const limit = limitCents ?? 0;
@@ -116,6 +156,12 @@ module.exports = function createDashboardRouter(handlers) {
   return async function dashboardRoute(req, res, ctx, pathname, method) {
     // POST /api/companies -- register a company at runtime (for tests and dynamic wizard creation)
     if (method === 'POST' && pathname === '/api/companies') {
+      // C-2 fix: guard against null handler — use /api/daemon/register-company instead
+      if (!handleRegisterCompany) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Company registration via /api/companies is not configured. Use POST /api/daemon/register-company instead.' }));
+        return true;
+      }
       await handleRegisterCompany(req, res, ctx);
       return true;
     }

package/daemon/routes/dept.js

@@ -149,7 +149,16 @@ module.exports = function createDeptRoute({ mgQuery, broadcast, semanticUpdater
            pcp.rationale    = $rationale,
            pcp.status       = 'pending',
            pcp.updatedAt    = datetime()`,
-        { proposalId, cid, pillarId, dept, section, proposedChange: String(proposedChange), rationale: rationale ? String(rationale) : '', authorId }
+         { proposalId, cid, pillarId, dept, section, proposedChange: String(proposedChange), rationale: rationale ? String(rationale) : '', authorId }
+      );
+
+      // P1-C: Create Approval node for plan_change_review so it surfaces in GET /api/hbo/approvals
+      await mgQuery(
+        `MERGE (a:Approval {id: $approvalId})
+         ON CREATE SET a.type = 'plan_change_review', a.companyId = $cid, a.status = 'pending',
+                       a.proposalId = $proposalId, a.createdAt = datetime()
+         ON MATCH SET  a.status = 'pending', a.proposalId = $proposalId`,
+        { approvalId: `approval:pcp:${proposalId}`, proposalId, cid }
       );
 
       // Respond immediately — LLM analysis is async

package/daemon/routes/email-triage.js

@@ -16,14 +16,16 @@ const { spawn } = require('child_process');
 const path = require('path');
 
 const HOME = homedir();
-const TRIAGE_DATA = join(HOME, 'helios-agent', 'data', 'email-triage');
+const HELIOS_ROOT = process.env.HELIOS_ROOT
+  || join(HOME, 'Desktop', 'Helios', 'helios-agent-main');
+const TRIAGE_DATA = join(HELIOS_ROOT, 'data', 'email-triage');
 const BRIEFING_PATH = join(TRIAGE_DATA, 'latest-briefing.json');
 const INBOX_PATH = join(TRIAGE_DATA, 'latest-inbox.json');
 const DRAFTS_PATH = join(TRIAGE_DATA, 'drafted-responses.json');
-const DASHBOARD_PATH = join(HOME, 'helios-agent', 'daemon', 'triage', 'dashboard.html');
+const DASHBOARD_PATH = join(HELIOS_ROOT, 'daemon', 'triage', 'dashboard.html');
 
 // ─── Backfill Process Mutex (PID file) ──────────────────────────────────────
-const BACKFILL_PID_FILE = path.join(HOME, 'helios-agent', 'data', 'backfill.pid');
+const BACKFILL_PID_FILE = path.join(HELIOS_ROOT, 'data', 'backfill.pid');
 
 function isBackfillRunning() {
   try {
@@ -64,14 +66,14 @@ function jsonResponse(res, status, data) {
  */
 async function regenerateDashboard() {
   return new Promise((resolve) => {
-    const updaterPath = join(HOME, 'helios-agent', 'scripts', 'update-dashboard.js');
+    const updaterPath = join(HELIOS_ROOT, 'scripts', 'update-dashboard.js');
     if (!existsSync(updaterPath)) {
       console.warn('[email-triage] update-dashboard.js not found — skipping regen');
       resolve();
       return;
     }
     const child = spawn(process.execPath, [updaterPath], {
-      cwd: join(HOME, 'helios-agent'),
+      cwd: HELIOS_ROOT,
       env: { ...process.env },
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
@@ -237,6 +239,7 @@ module.exports = function emailTriageRoute({ broadcast } = {}) {
       // Parse optional body for config
       let since = '30d';
       let limit = 100;
+      let account = null;
       try {
         const chunks = [];
         await new Promise((resolve, reject) => {
@@ -247,6 +250,7 @@ module.exports = function emailTriageRoute({ broadcast } = {}) {
         const body = chunks.length > 0 ? JSON.parse(Buffer.concat(chunks).toString()) : {};
         if (body.since) since = body.since;
         if (body.limit) limit = parseInt(body.limit, 10) || 100;
+        if (body.account) account = body.account;
       } catch (_) { /* use defaults */ }
 
       // Set up SSE headers
@@ -268,10 +272,12 @@ module.exports = function emailTriageRoute({ broadcast } = {}) {
 
       // Resolve the backfill script — prefer run-backfill-30d.ts (full triage + drafts)
       const scriptCandidates = [
-        join(HOME, 'helios-agent', 'run-backfill-30d.ts'),        // W1-3: correct script (full 5-phase email triage + drafts)
-        join(HOME, 'helios-agent', 'run-triage-backfill.ts'),     // legacy name (does not exist, kept as fallback)
-        join(HOME, 'helios-agent', 'extensions', 'email', 'backfill.ts'), // graph ingestion only
-        join(HOME, 'helios-agent', 'scripts', 'run-backfill.ts'), // full graph backfill (wrong for email triage)
+        process.env.HELIOS_ROOT
+          ? join(process.env.HELIOS_ROOT, 'run-backfill-30d.ts')
+          : join(HOME, 'Desktop', 'Helios', 'helios-agent-main', 'run-backfill-30d.ts'),  // W1-3: correct script (full 5-phase email triage + drafts)
+        join(HELIOS_ROOT, 'run-triage-backfill.ts'),     // legacy name (does not exist, kept as fallback)
+        join(HELIOS_ROOT, 'extensions', 'email', 'backfill.ts'), // graph ingestion only
+        join(HELIOS_ROOT, 'scripts', 'run-backfill.ts'), // full graph backfill (wrong for email triage)
       ];
 
       const scriptPath = scriptCandidates.find(p => existsSync(p));
@@ -293,17 +299,20 @@ module.exports = function emailTriageRoute({ broadcast } = {}) {
       }
 
       const args = [scriptPath, '--since', sinceDate, '--limit', limit];
+      if (account) args.push('--account', account);
       sendSSE({ phase: 1, message: `Running: npx tsx ${path.basename(scriptPath)} --since ${sinceDate} --limit ${limit}` });
 
       let child;
       try {
         // C6: use npx.cmd on Windows so spawn finds the correct executable
+        // shell:true required on Windows for .cmd files (EINVAL without it)
         const npxBin = process.platform === 'win32' ? 'npx.cmd' : 'npx';
         child = spawn(npxBin, ['tsx', ...args], {
-          cwd: join(HOME, 'helios-agent'),
+          cwd: HELIOS_ROOT,
           env: { ...process.env, HELIOS_SKIP_INTERNAL_DASHBOARD_REGEN: '1' },
           stdio: ['ignore', 'pipe', 'pipe'],
           windowsHide: true,
+          shell: process.platform === 'win32',
         });
       } catch (spawnErr) {
         sendSSE({ phase: -1, message: `Spawn error: ${spawnErr.message}`, error: true, done: true });