@cgh567/agent 2.4.2 → 2.4.4

package/daemon/routes/routines.js

@@ -14,6 +14,8 @@
 
 module.exports = function createRoutinesRouter(handlers) {
   const {
+    handleGetRoutines,
+    handleCreateRoutine,
     handleGetRoutineTriggers,
     handleCreateRoutineTrigger,
     handleFireWebhookTrigger,
@@ -30,6 +32,18 @@ module.exports = function createRoutinesRouter(handlers) {
       return true;
     }
 
+    // P5-01: GET /api/routines — list routines for a company (must be before /:id routes)
+    if (method === 'GET' && pathname === '/api/routines') {
+      await handleGetRoutines(req, res, ctx);
+      return true;
+    }
+
+    // P5-02: POST /api/routines — create a new routine
+    if (method === 'POST' && pathname === '/api/routines') {
+      await handleCreateRoutine(req, res, ctx);
+      return true;
+    }
+
     // PATCH /api/routines/:id (edit routine → creates revision)
     const patchRoutineMatch = pathname.match(/^\/api\/routines\/([^/]+)$/);
     if (method === 'PATCH' && patchRoutineMatch) {

package/daemon/routes/tasks.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const VALID_TASK_STATUSES = new Set(['todo', 'in_progress', 'done', 'failed', 'cancelled']);
+// NOTE: Task status validation is handled in handleUpdateTask (helios-api.js VALID_STATUSES).
+// The canonical valid statuses include: todo, in_progress, done, failed, cancelled, blocked, escalated, in_review.
 
 /**
  * routes/tasks.js — Task-related route dispatch
@@ -26,6 +27,7 @@ module.exports = function createTasksRouter(handlers) {
     handleGetTaskComments,
     handlePostTaskComment,
     handlePatchTask,
+    handlePatchTaskPolicy,  // P4-07: PATCH /api/tasks/:id/policy
   } = handlers;
 
   return async function tasksRoute(req, res, ctx, pathname, method) {
@@ -89,6 +91,18 @@ module.exports = function createTasksRouter(handlers) {
       return true;
     }
 
+    // PATCH /api/tasks/:id/policy — P4-07: set executionPolicy on a task
+    const policyMatch = pathname.match(/^\/api\/tasks\/([^/]+)\/policy$/);
+    if (method === 'PATCH' && policyMatch) {
+      if (handlePatchTaskPolicy) {
+        await handlePatchTaskPolicy(req, res, ctx, decodeURIComponent(policyMatch[1]));
+      } else {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Policy endpoint not configured' }));
+      }
+      return true;
+    }
+
     return false;
   };
 };

package/daemon/schema-apply.js

@@ -0,0 +1,174 @@
+'use strict';
+/**
+ * schema-apply.js — Converges the Memgraph graph to the canonical schema.
+ *
+ * Uses Memgraph MAGE's schema.assert() procedure to atomically create missing
+ * indexes and uniqueness constraints, keep existing correct ones, and optionally
+ * drop anything that doesn't belong (controlled by dropExisting flag).
+ *
+ * Composite indexes (multi-property) are applied via separate Cypher statements
+ * because schema.assert() only handles single-property label indexes.
+ *
+ * Called once during daemon startup, after Memgraph connection is established
+ * and before any tick processing begins.
+ *
+ * Usage:
+ *   const { applySchema } = require('./schema-apply');
+ *   await applySchema(mgQuery);          // safe for rolling deployments
+ *   await applySchema(mgQuery, true);    // drop_existing — use on fresh installs
+ */
+
+const { INDEXES, COMPOSITE_INDEXES, UNIQUE_CONSTRAINTS } = require('./schema-definitions');
+
+/**
+ * @param {Function} mgQuery  async (cypher, params?) => { rows, keys }
+ * @param {boolean}  [dropExisting=false]
+ *   false = safe for live deployments — adds missing, keeps existing, never drops.
+ *   true  = converge exactly — drops indexes/constraints not in the definition.
+ *           Use on fresh installs or after intentional schema cleanup.
+ */
+async function applySchema(mgQuery, dropExisting = false) {
+  const log = (msg) => console.log('[schema-apply]', msg);
+  const warn = (msg) => console.warn('[schema-apply] WARN:', msg);
+
+  // ── Step 1: schema.assert() for single-property indexes + unique constraints
+  log(`Applying schema via schema.assert() (drop_existing=${dropExisting})…`);
+
+  let assertResult;
+  try {
+    assertResult = await mgQuery(
+      `CALL schema.assert($indices, $unique, {}, $drop)
+       YIELD action, label, key, unique
+       RETURN action, label, key, unique`,
+      {
+        indices: INDEXES,
+        unique:  UNIQUE_CONSTRAINTS,
+        drop:    dropExisting,
+      }
+    );
+  } catch (err) {
+    // schema.assert() is a MAGE procedure — if MAGE is not installed or the
+    // version doesn't include the schema module, fall back gracefully to the
+    // per-statement legacy approach.
+    warn(`schema.assert() unavailable: ${err.message}`);
+    warn('Falling back to per-statement legacy migration.');
+    return _legacyFallback(mgQuery);
+  }
+
+  // ── Parse and log results ────────────────────────────────────────────────
+  const rows = assertResult?.rows ?? [];
+  const counts = { Created: 0, Kept: 0, Dropped: 0 };
+
+  for (const row of rows) {
+    // Memgraph returns rows as arrays or objects depending on driver config
+    const action = Array.isArray(row) ? row[0] : row.action;
+    const label  = Array.isArray(row) ? row[1] : row.label;
+    const key    = Array.isArray(row) ? row[2] : row.key;
+    const unique = Array.isArray(row) ? row[3] : row.unique;
+
+    const kind = unique ? 'constraint' : 'index';
+    if (action === 'Created') {
+      log(`  ✓ Created ${kind}: :${label}(${key})`);
+    } else if (action === 'Dropped') {
+      log(`  ✗ Dropped ${kind}: :${label}(${key})`);
+    }
+    // Kept entries are silent — too noisy otherwise
+    if (counts[action] !== undefined) counts[action]++;
+  }
+
+  log(`schema.assert() complete — Created: ${counts.Created}, Kept: ${counts.Kept}, Dropped: ${counts.Dropped}`);
+
+  // ── Step 2: Composite indexes ─────────────────────────────────────────────
+  // schema.assert() does not support composite indexes, so we create them
+  // individually. Each uses CREATE INDEX ON :Label(propA, propB) with a
+  // try/catch to silently skip "already exists" errors.
+  let compositeCreated = 0;
+  let compositeSkipped = 0;
+
+  for (const { label, props } of COMPOSITE_INDEXES) {
+    const propList = props.join(', ');
+    const cypher = `CREATE INDEX ON :${label}(${propList})`;
+    try {
+      await mgQuery(cypher);
+      log(`  ✓ Created composite index: :${label}(${propList})`);
+      compositeCreated++;
+    } catch (err) {
+      // "already exists" is the expected no-op case
+      const msg = err.message ?? '';
+      if (/already exists/i.test(msg) || /constraint.*exists/i.test(msg) || /index.*exists/i.test(msg)) {
+        compositeSkipped++;
+      } else {
+        warn(`Composite index :${label}(${propList}) failed: ${msg}`);
+      }
+    }
+  }
+
+  if (compositeCreated > 0 || compositeSkipped > 0) {
+    log(`Composite indexes — Created: ${compositeCreated}, Already existed: ${compositeSkipped}`);
+  }
+
+  log('Schema application complete.');
+}
+
+// ── Legacy fallback ───────────────────────────────────────────────────────────
+// Used when schema.assert() is unavailable (MAGE not installed or older version).
+// Runs each constraint/index as individual CREATE statements with try/catch.
+// This is the old seven-migration-file behaviour, condensed into one function.
+
+async function _legacyFallback(mgQuery) {
+  const log  = (msg) => console.log('[schema-apply/legacy]', msg);
+  const warn = (msg) => console.warn('[schema-apply/legacy] WARN:', msg);
+
+  log('Running legacy per-statement schema migration…');
+
+  let created = 0;
+  let skipped = 0;
+  let failed  = 0;
+
+  async function exec(cypher) {
+    try {
+      await mgQuery(cypher);
+      created++;
+    } catch (err) {
+      const msg = err.message ?? '';
+      if (/already exists/i.test(msg) || /constraint.*exists/i.test(msg) || /index.*exists/i.test(msg)) {
+        skipped++;
+      } else {
+        warn(`${cypher} → ${msg}`);
+        failed++;
+      }
+    }
+  }
+
+  // Unique constraints
+  for (const [label, constraintGroups] of Object.entries(UNIQUE_CONSTRAINTS)) {
+    for (const props of constraintGroups) {
+      if (props.length === 1) {
+        await exec(`CREATE CONSTRAINT ON (n:${label}) ASSERT n.${props[0]} IS UNIQUE`);
+      } else {
+        // Composite unique — old syntax doesn't support this cleanly; use new syntax
+        await exec(`CREATE CONSTRAINT FOR (n:${label}) REQUIRE (${props.map(p => `n.${p}`).join(', ')}) IS UNIQUE`);
+      }
+    }
+  }
+
+  // Single-property indexes
+  for (const [label, props] of Object.entries(INDEXES)) {
+    for (const prop of props) {
+      if (prop === '') {
+        await exec(`CREATE INDEX ON :${label}`);
+      } else {
+        await exec(`CREATE INDEX ON :${label}(${prop})`);
+      }
+    }
+  }
+
+  // Composite indexes
+  for (const { label, props } of COMPOSITE_INDEXES) {
+    await exec(`CREATE INDEX ON :${label}(${props.join(', ')})`);
+  }
+
+  log(`Legacy migration complete — Created: ${created}, Skipped: ${skipped}, Failed: ${failed}`);
+}
+
+module.exports = { applySchema };