wogiflow 2.4.4 → 2.5.0

package/lib/workspace-routing.js

@@ -11,6 +11,18 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
+const http = require('node:http');
+
+let _workspaceMessages;
+function getWorkspaceMessages() {
+  if (!_workspaceMessages) {
+    _workspaceMessages = require('./workspace-messages');
+  }
+  return _workspaceMessages;
+}
+
+// Shared phase ordering — used by both getExecutionOrder() and dispatchCrossRepoPlan()
+const PHASE_ORDER = { library: 0, contract: 0, provider: 1, both: 1, consumer: 2, standalone: 3, verify: 4 };
 
 // ============================================================
 // Routing Keywords (Criterion 1)
@@ -384,7 +396,14 @@ Be specific about file names, line numbers, and error messages.`,
  */
 function decomposeToRepoTasks(workspaceRoot, workspaceTask, plan) {
   const configPath = path.join(workspaceRoot, 'wogi-workspace.json');
-  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  let config;
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    config = JSON.parse(raw);
+    if (!config || typeof config !== 'object') return [];
+  } catch (_err) {
+    return []; // Graceful fallback — config missing or malformed
+  }
   const createdTasks = [];
 
   for (const step of plan.executionOrder) {
@@ -442,7 +461,6 @@ function decomposeToRepoTasks(workspaceRoot, workspaceTask, plan) {
  */
 function getExecutionOrder(manifest, targetRepos) {
   const order = [];
-  const phaseOrder = { library: 0, provider: 1, both: 1, consumer: 2, standalone: 3 };
 
   for (const name of targetRepos) {
     const member = manifest.members[name];
@@ -451,7 +469,7 @@ function getExecutionOrder(manifest, targetRepos) {
       name,
       role: member.role,
       phase: member.role,
-      order: phaseOrder[member.role] ?? 3
+      order: PHASE_ORDER[member.role] ?? 3
     });
   }
 
@@ -461,6 +479,277 @@ function getExecutionOrder(manifest, targetRepos) {
   return order;
 }
 
+// ============================================================
+// Channel-Based Dispatch (wf-d4b98f60)
+// ============================================================
+
+/**
+ * Send an HTTP POST to a worker's channel server.
+ *
+ * @param {string} host — hostname (default '127.0.0.1')
+ * @param {number} port — worker's channel port
+ * @param {string} message — message body to send
+ * @param {Object} [opts] — options
+ * @param {string} [opts.from] — sender identifier
+ * @param {number} [opts.timeout] — request timeout in ms (default 5000)
+ * @returns {Promise<{ ok: boolean, status: number, body: string }>}
+ */
+function httpPost(host, port, message, opts = {}) {
+  const timeout = opts.timeout ?? 5000;
+  const from = opts.from ?? 'workspace-manager';
+  const buf = Buffer.from(message, 'utf-8');
+
+  return new Promise((resolve) => {
+    const req = http.request({
+      hostname: host,
+      port,
+      path: '/',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'text/plain',
+        'Content-Length': buf.byteLength,
+        'X-Wogi-From': from
+      },
+      timeout
+    }, (res) => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => resolve({ ok: res.statusCode === 200, status: res.statusCode, body: Buffer.concat(chunks).toString('utf-8') }));
+    });
+
+    req.on('error', (err) => resolve({ ok: false, status: 0, body: err.message }));
+    req.on('timeout', () => { req.destroy(); resolve({ ok: false, status: 0, body: 'timeout' }); });
+    req.write(buf);
+    req.end();
+  });
+}
+
+/**
+ * Check if a worker's channel server is running.
+ *
+ * @param {number} port
+ * @returns {Promise<{ up: boolean, repo: string }>}
+ */
+function checkWorkerHealth(port) {
+  return new Promise((resolve) => {
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port,
+      path: '/health',
+      method: 'GET',
+      timeout: 3000
+    }, (res) => {
+      let body = '';
+      res.on('data', chunk => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          resolve({ up: data.status === 'ok', repo: data.repo || 'unknown' });
+        } catch (_err) {
+          resolve({ up: false, repo: 'unknown' });
+        }
+      });
+    });
+
+    req.on('error', () => resolve({ up: false, repo: 'unknown' }));
+    req.on('timeout', () => { req.destroy(); resolve({ up: false, repo: 'unknown' }); });
+    req.end();
+  });
+}
+
+/**
+ * Dispatch a task to a single worker via its channel.
+ *
+ * @param {string} workspaceRoot
+ * @param {string} repoName — target repo
+ * @param {string} taskId — task ID to start
+ * @returns {Promise<{ ok: boolean, message: string }>}
+ */
+async function dispatchToChannel(workspaceRoot, repoName, taskId) {
+  // Validate taskId format to prevent injection into channel body
+  if (!/^wf-[0-9a-f]{8}$/i.test(taskId)) {
+    return { ok: false, message: `Invalid task ID format: "${taskId}" — expected wf-XXXXXXXX` };
+  }
+
+  const configPath = path.join(workspaceRoot, 'wogi-workspace.json');
+  let config;
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    config = JSON.parse(raw);
+    if (!config || typeof config !== 'object') throw new Error('Invalid config format');
+  } catch (err) {
+    return { ok: false, message: `Cannot read workspace config: ${err.message}` };
+  }
+
+  const channelConfig = config.channels?.members?.[repoName];
+  if (!channelConfig) {
+    return { ok: false, message: `No channel config for repo "${repoName}"` };
+  }
+
+  const port = channelConfig.port;
+
+  // Health check first
+  const health = await checkWorkerHealth(port);
+  if (!health.up) {
+    return {
+      ok: false,
+      message: `Worker "${repoName}" is not running on port ${port}. Start it with: cd ${repoName}/ && flow workspace start`
+    };
+  }
+
+  // Dispatch the task
+  const result = await httpPost('127.0.0.1', port, `/wogi-start ${taskId}`);
+  if (result.ok) {
+    return { ok: true, message: `Dispatched /wogi-start ${taskId} to ${repoName} (port ${port})` };
+  }
+
+  return { ok: false, message: `Dispatch failed: HTTP ${result.status} — ${result.body}` };
+}
+
+/**
+ * Dispatch a cross-repo execution plan to workers.
+ * Respects phase ordering: library → provider → consumer.
+ * Within a phase, dispatches in parallel. Between phases, waits for completion.
+ *
+ * @param {string} workspaceRoot
+ * @param {Array} createdTasks — from decomposeToRepoTasks()
+ * @param {Object} [opts]
+ * @param {boolean} [opts.parallel] — dispatch all at once ignoring phases (default false)
+ * @returns {Promise<{ dispatched: Array, failed: Array }>}
+ */
+async function dispatchCrossRepoPlan(workspaceRoot, createdTasks, opts = {}) {
+  const dispatched = [];
+  const failed = [];
+
+  if (opts.parallel) {
+    // Dispatch all tasks at once
+    const results = await Promise.all(
+      createdTasks.map(ct =>
+        dispatchToChannel(workspaceRoot, ct.repo, ct.task.id)
+          .then(r => ({ ...r, repo: ct.repo, taskId: ct.task.id, phase: ct.phase }))
+      )
+    );
+    for (const r of results) {
+      (r.ok ? dispatched : failed).push(r);
+    }
+  } else {
+    // Group by phase order: library(0) → provider(1) → consumer(2) → standalone(3)
+    const grouped = {};
+    for (const ct of createdTasks) {
+      const order = PHASE_ORDER[ct.phase] ?? 3;
+      if (!grouped[order]) grouped[order] = [];
+      grouped[order].push(ct);
+    }
+
+    // Execute phases in order
+    const sortedPhases = Object.keys(grouped).map(Number).sort((a, b) => a - b);
+    for (const phase of sortedPhases) {
+      const tasks = grouped[phase];
+      const results = await Promise.all(
+        tasks.map(ct =>
+          dispatchToChannel(workspaceRoot, ct.repo, ct.task.id)
+            .then(r => ({ ...r, repo: ct.repo, taskId: ct.task.id, phase: ct.phase }))
+        )
+      );
+      for (const r of results) {
+        (r.ok ? dispatched : failed).push(r);
+      }
+
+      // Wait for this phase to complete before starting the next
+      const phaseTaskIds = results.filter(r => r.ok).map(r => r.taskId);
+      if (phaseTaskIds.length > 0 && phase !== sortedPhases[sortedPhases.length - 1]) {
+        const completion = await waitForCompletion(workspaceRoot, phaseTaskIds, {
+          timeoutMs: opts.phaseTimeoutMs ?? 15 * 60 * 1000 // 15 min per phase
+        });
+        if (completion.timedOut) {
+          // Abort further phases — provider didn't finish
+          failed.push({ ok: false, message: `Phase timed out waiting for: ${completion.pending.join(', ')}`, phase });
+          break;
+        }
+      }
+    }
+  }
+
+  return { dispatched, failed };
+}
+
+// ============================================================
+// Completion Monitoring (wf-d4b98f60)
+// ============================================================
+
+/**
+ * Wait for workspace tasks to complete by polling the message bus.
+ *
+ * @param {string} workspaceRoot
+ * @param {string[]} taskIds — task IDs to wait for
+ * @param {Object} [opts]
+ * @param {number} [opts.pollIntervalMs] — poll interval (default 5000)
+ * @param {number} [opts.timeoutMs] — max wait time (default 1800000 = 30min)
+ * @returns {Promise<{ completed: string[], pending: string[], timedOut: boolean }>}
+ */
+async function waitForCompletion(workspaceRoot, taskIds, opts = {}) {
+  const pollInterval = opts.pollIntervalMs ?? 5000;
+  const timeout = opts.timeoutMs ?? 30 * 60 * 1000;
+  const startTime = Date.now();
+  const startIso = new Date(startTime).toISOString();
+  const completed = new Set();
+  const taskIdSet = new Set(taskIds);
+
+  let readMessages, updateMessageStatus;
+  try {
+    const bus = getWorkspaceMessages();
+    readMessages = bus.readMessages;
+    updateMessageStatus = bus.updateMessageStatus;
+  } catch (_err) {
+    return { completed: [], pending: [...taskIds], timedOut: false, error: 'Cannot load workspace-messages module' };
+  }
+
+  while (completed.size < taskIds.length) {
+    if (Date.now() - startTime > timeout) {
+      return {
+        completed: [...completed],
+        pending: taskIds.filter(id => !completed.has(id)),
+        timedOut: true
+      };
+    }
+
+    // Read task-complete messages created AFTER we started waiting
+    try {
+      const messages = readMessages(workspaceRoot, { type: 'task-complete', status: 'pending' });
+      for (const msg of messages) {
+        // Only consider messages created after we started waiting
+        if (msg.timestamp && msg.timestamp < startIso) continue;
+
+        // Exact match on structured taskId field, or fallback to subject
+        const msgTaskId = msg.taskId || msg.subject;
+        if (msgTaskId && taskIdSet.has(msgTaskId) && !completed.has(msgTaskId)) {
+          completed.add(msgTaskId);
+          // Mark message as acknowledged so it's not re-processed
+          try {
+            if (updateMessageStatus) {
+              updateMessageStatus(workspaceRoot, msg.id, 'acknowledged');
+            }
+          } catch (_err) {
+            // Non-critical
+          }
+        }
+      }
+    } catch (_err) {
+      // Non-critical — retry on next poll
+    }
+
+    if (completed.size < taskIds.length) {
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+  }
+
+  return {
+    completed: [...completed],
+    pending: [],
+    timedOut: false
+  };
+}
+
 // ============================================================
 // Exports
 // ============================================================
@@ -481,5 +770,13 @@ module.exports = {
   decomposeToRepoTasks,
 
   // Ordering
-  getExecutionOrder
+  getExecutionOrder,
+
+  // Channel dispatch
+  dispatchToChannel,
+  dispatchCrossRepoPlan,
+  checkWorkerHealth,
+
+  // Completion monitoring
+  waitForCompletion
 };