@adhdev/daemon-core 0.9.82-rc.6 → 0.9.82-rc.61

package/src/mesh/mesh-work-queue.ts

@@ -1,20 +1,70 @@
-import { existsSync, writeFileSync, readFileSync } from 'fs';
+import { existsSync, writeFileSync, readFileSync, openSync, closeSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { getLedgerDir } from './mesh-ledger.js';
+import { requireMeshHostQueueOwner } from './mesh-host-ownership.js';
+import type { RepoMeshDaemonRole } from '../repo-mesh-types.js';
 
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
 export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+export type MeshTaskMode = 'code_change' | 'validation' | 'live_debug_readonly' | 'launch_app' | 'convergence';
 
 export const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[] = ['pending', 'assigned'];
 export const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[] = ['completed', 'failed', 'cancelled'];
+export const MESH_TASK_MODES: MeshTaskMode[] = ['code_change', 'validation', 'live_debug_readonly', 'launch_app', 'convergence'];
+
+export interface MeshTaskModeValidationResult {
+    valid: boolean;
+    taskMode?: MeshTaskMode;
+    violations: string[];
+    allowedOperations?: string[];
+}
+
+const LIVE_DEBUG_READONLY_FORBIDDEN: Array<{ label: string; pattern: RegExp }> = [
+    { label: 'source_edit', pattern: /\b(edit|modify|patch|apply\s+patch|write\s+(?:to\s+)?(?:file|source)|overwrite|delete\s+file|remove\s+file|create\s+file|touch\s+file)\b/i },
+    { label: 'git_mutation', pattern: /\b(?:git\s+(?:add|commit|push|reset|rebase|clean|checkout|switch|merge|tag|restore|rm|mv)|push\b)/i },
+    { label: 'checkpoint', pattern: /\b(checkpoint|mesh_checkpoint)\b/i },
+    { label: 'deploy_or_version_bump', pattern: /\b(deploy|wrangler\s+deploy|version[-\s]?bump|npm\s+version|release)\b/i },
+    { label: 'destructive_shell', pattern: /\b(rm\s+-rf|mv\s+\S+\s+\S+|truncate\s|tee\s+\S+|sed\s+-i)\b/i },
+];
+
+export function normalizeMeshTaskMode(value: unknown): MeshTaskMode | undefined {
+    if (typeof value !== 'string') return undefined;
+    const normalized = value.trim() as MeshTaskMode;
+    return (MESH_TASK_MODES as string[]).includes(normalized) ? normalized : undefined;
+}
+
+export function validateMeshTaskModeRequest(mode: unknown, message: string): MeshTaskModeValidationResult {
+    const taskMode = normalizeMeshTaskMode(mode);
+    if (!taskMode) {
+        return { valid: true, violations: [] };
+    }
+    if (taskMode !== 'live_debug_readonly') {
+        return { valid: true, taskMode, violations: [] };
+    }
+    const violations = LIVE_DEBUG_READONLY_FORBIDDEN
+        .filter(rule => rule.pattern.test(message || ''))
+        .map(rule => rule.label);
+    return {
+        valid: violations.length === 0,
+        taskMode,
+        violations,
+        allowedOperations: [
+            'process/log/window/port/session inspection',
+            'read-only filesystem listing/reading',
+            'status probes and keep-running handle reporting',
+            'diagnostic summaries without source edits, commits, checkpoints, pushes, deploys, resets, rebases, or destructive cleanups',
+        ],
+    };
+}
 
 export interface MeshWorkQueueEntry {
     id: string;
     meshId: string;
     message: string;
     status: MeshTaskStatus;
+    taskMode?: MeshTaskMode;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
     /** If specified, only this runtime session can claim the task */
@@ -45,11 +95,40 @@ export interface MeshWorkQueueEntry {
     updatedAt: string;
 }
 
+export interface MeshQueueMutationOptions {
+    ownerRole?: RepoMeshDaemonRole;
+}
+
 function getQueuePath(meshId: string): string {
     const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
     return join(getLedgerDir(), `${safe}.queue.json`);
 }
 
+function getLockPath(meshId: string): string {
+    const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return join(getLedgerDir(), `${safe}.queue.lock`);
+}
+
+/**
+ * Simple advisory file lock using O_EXCL (atomic create) for queue mutations.
+ * Retries up to 10 times at 30 ms intervals; proceeds without lock on timeout
+ * to prevent deadlock (best-effort — far better than no locking at all).
+ */
+function withQueueLock<T>(meshId: string, fn: () => T): T {
+    const lockPath = getLockPath(meshId);
+    let fd = -1;
+    for (let i = 0; i < 10; i++) {
+        try { fd = openSync(lockPath, 'wx'); break; } catch {
+            const deadline = Date.now() + 30;
+            while (Date.now() < deadline) { /* spin */ }
+        }
+    }
+    try { return fn(); } finally {
+        if (fd !== -1) try { closeSync(fd); } catch { /* noop */ }
+        try { unlinkSync(lockPath); } catch { /* already removed */ }
+    }
+}
+
 function readQueue(meshId: string): MeshWorkQueueEntry[] {
     const path = getQueuePath(meshId);
     if (!existsSync(path)) return [];
@@ -72,22 +151,30 @@ function writeQueue(meshId: string, queue: MeshWorkQueueEntry[]): void {
 export function enqueueTask(
     meshId: string,
     message: string,
-    opts?: { targetNodeId?: string; targetSessionId?: string }
+    opts?: { targetNodeId?: string; targetSessionId?: string; taskMode?: MeshTaskMode | string } & MeshQueueMutationOptions,
 ): MeshWorkQueueEntry {
-    const queue = readQueue(meshId);
-    const entry: MeshWorkQueueEntry = {
-        id: randomUUID(),
-        meshId,
-        message,
-        status: 'pending',
-        targetNodeId: opts?.targetNodeId,
-        targetSessionId: opts?.targetSessionId,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-    };
-    queue.push(entry);
-    writeQueue(meshId, queue);
-    return entry;
+    requireMeshHostQueueOwner(opts);
+    const modeValidation = validateMeshTaskModeRequest(opts?.taskMode, message);
+    if (!modeValidation.valid) {
+        throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(', ')})`);
+    }
+    return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const entry: MeshWorkQueueEntry = {
+            id: randomUUID(),
+            meshId,
+            message,
+            status: 'pending',
+            taskMode: modeValidation.taskMode,
+            targetNodeId: opts?.targetNodeId,
+            targetSessionId: opts?.targetSessionId,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        queue.push(entry);
+        writeQueue(meshId, queue);
+        return entry;
+    });
 }
 
 /**
@@ -106,39 +193,29 @@ export function getQueue(meshId: string, opts?: { status?: MeshTaskStatus[] }):
  * Find the next pending task that this node is allowed to claim, and mark it as assigned.
  */
 export function claimNextTask(meshId: string, nodeId: string, sessionId: string): MeshWorkQueueEntry | null {
-    const queue = readQueue(meshId);
-
-    // A worker must finish or fail its current queued assignment before it can
-    // claim another one. maxParallelTasks limits total mesh concurrency; it is
-    // not permission for one node/session to accumulate multiple assigned items.
-    const hasActiveAssignment = queue.some(q => q.status === 'assigned' && (
-        q.assignedSessionId === sessionId || q.assignedNodeId === nodeId
-    ));
-    if (hasActiveAssignment) return null;
-    
-    // Find highest priority task:
-    // 1. Pending tasks explicitly targeted at this runtime session
-    // 2. Pending tasks explicitly targeted at this node (but not another session)
-    // 3. Pending tasks with no target node/session
-    let targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetSessionId === sessionId);
-    if (targetIdx === -1) {
-        targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetNodeId === nodeId && !q.targetSessionId);
-    }
-    if (targetIdx === -1) {
-        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId && !q.targetSessionId);
-    }
-
-    if (targetIdx === -1) return null;
-
-    const entry = queue[targetIdx];
-    entry.status = 'assigned';
-    entry.assignedNodeId = nodeId;
-    entry.assignedSessionId = sessionId;
-    entry.dispatchTimestamp = new Date().toISOString();
-    entry.updatedAt = new Date().toISOString();
-
-    writeQueue(meshId, queue);
-    return entry;
+    return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const hasActiveAssignment = queue.some(q => q.status === 'assigned' && (
+            q.assignedSessionId === sessionId || q.assignedNodeId === nodeId
+        ));
+        if (hasActiveAssignment) return null;
+        let targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetSessionId === sessionId);
+        if (targetIdx === -1) {
+            targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetNodeId === nodeId && !q.targetSessionId);
+        }
+        if (targetIdx === -1) {
+            targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId && !q.targetSessionId);
+        }
+        if (targetIdx === -1) return null;
+        const entry = queue[targetIdx];
+        entry.status = 'assigned';
+        entry.assignedNodeId = nodeId;
+        entry.assignedSessionId = sessionId;
+        entry.dispatchTimestamp = new Date().toISOString();
+        entry.updatedAt = new Date().toISOString();
+        writeQueue(meshId, queue);
+        return entry;
+    });
 }
 
 /**
@@ -149,15 +226,18 @@ export function updateTaskStatus(
     meshId: string,
     taskId: string,
     status: MeshTaskStatus,
+    opts?: MeshQueueMutationOptions,
 ): MeshWorkQueueEntry | null {
-    const queue = readQueue(meshId);
-    const idx = queue.findIndex(q => q.id === taskId);
-    if (idx === -1) return null;
-
-    queue[idx].status = status;
-    queue[idx].updatedAt = new Date().toISOString();
-    writeQueue(meshId, queue);
-    return queue[idx];
+    requireMeshHostQueueOwner(opts);
+    return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex(q => q.id === taskId);
+        if (idx === -1) return null;
+        queue[idx].status = status;
+        queue[idx].updatedAt = new Date().toISOString();
+        writeQueue(meshId, queue);
+        return queue[idx];
+    });
 }
 
 export function recordTaskAutoLaunch(
@@ -165,17 +245,16 @@ export function recordTaskAutoLaunch(
     taskId: string,
     autoLaunch: Omit<NonNullable<MeshWorkQueueEntry['autoLaunch']>, 'updatedAt'>,
 ): MeshWorkQueueEntry | null {
-    const queue = readQueue(meshId);
-    const idx = queue.findIndex(q => q.id === taskId);
-    if (idx === -1) return null;
-    const now = new Date().toISOString();
-    queue[idx].autoLaunch = {
-        ...autoLaunch,
-        updatedAt: now,
-    };
-    queue[idx].updatedAt = now;
-    writeQueue(meshId, queue);
-    return queue[idx];
+    return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex(q => q.id === taskId);
+        if (idx === -1) return null;
+        const now = new Date().toISOString();
+        queue[idx].autoLaunch = { ...autoLaunch, updatedAt: now };
+        queue[idx].updatedAt = now;
+        writeQueue(meshId, queue);
+        return queue[idx];
+    });
 }
 
 /**
@@ -184,19 +263,21 @@ export function recordTaskAutoLaunch(
 export function cancelTask(
     meshId: string,
     taskId: string,
-    opts?: { reason?: string },
+    opts?: { reason?: string } & MeshQueueMutationOptions,
 ): MeshWorkQueueEntry | null {
-    const queue = readQueue(meshId);
-    const idx = queue.findIndex(q => q.id === taskId);
-    if (idx === -1) return null;
-
-    const now = new Date().toISOString();
-    queue[idx].status = 'cancelled';
-    queue[idx].updatedAt = now;
-    queue[idx].cancelledAt = now;
-    if (opts?.reason) queue[idx].cancelReason = opts.reason;
-    writeQueue(meshId, queue);
-    return queue[idx];
+    requireMeshHostQueueOwner(opts);
+    return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex(q => q.id === taskId);
+        if (idx === -1) return null;
+        const now = new Date().toISOString();
+        queue[idx].status = 'cancelled';
+        queue[idx].updatedAt = now;
+        queue[idx].cancelledAt = now;
+        if (opts?.reason) queue[idx].cancelReason = opts.reason;
+        writeQueue(meshId, queue);
+        return queue[idx];
+    });
 }
 
 /**
@@ -212,29 +293,31 @@ export function requeueTask(
         targetSessionId?: string;
         clearTargetNode?: boolean;
         clearTargetSession?: boolean;
-    },
+    } & MeshQueueMutationOptions,
 ): MeshWorkQueueEntry | null {
-    const queue = readQueue(meshId);
-    const idx = queue.findIndex(q => q.id === taskId);
-    if (idx === -1) return null;
-
-    const entry = queue[idx];
-    const now = new Date().toISOString();
-    entry.status = 'pending';
-    delete entry.assignedNodeId;
-    delete entry.assignedSessionId;
-    delete entry.cancelledAt;
-    delete entry.cancelReason;
-    if (opts?.clearTargetNode) delete entry.targetNodeId;
-    if (typeof opts?.targetNodeId === 'string') entry.targetNodeId = opts.targetNodeId;
-    if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
-    if (typeof opts?.targetSessionId === 'string') entry.targetSessionId = opts.targetSessionId;
-    entry.updatedAt = now;
-    entry.requeuedAt = now;
-    entry.requeueCount = (entry.requeueCount || 0) + 1;
-    if (opts?.reason) entry.requeueReason = opts.reason;
-    writeQueue(meshId, queue);
-    return entry;
+    requireMeshHostQueueOwner(opts);
+    return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex(q => q.id === taskId);
+        if (idx === -1) return null;
+        const entry = queue[idx];
+        const now = new Date().toISOString();
+        entry.status = 'pending';
+        delete entry.assignedNodeId;
+        delete entry.assignedSessionId;
+        delete entry.cancelledAt;
+        delete entry.cancelReason;
+        if (opts?.clearTargetNode) delete entry.targetNodeId;
+        if (typeof opts?.targetNodeId === 'string') entry.targetNodeId = opts.targetNodeId;
+        if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
+        if (typeof opts?.targetSessionId === 'string') entry.targetSessionId = opts.targetSessionId;
+        entry.updatedAt = now;
+        entry.requeuedAt = now;
+        entry.requeueCount = (entry.requeueCount || 0) + 1;
+        if (opts?.reason) entry.requeueReason = opts.reason;
+        writeQueue(meshId, queue);
+        return entry;
+    });
 }
 
 /**
@@ -244,29 +327,26 @@ export function updateSessionTaskStatus(
     meshId: string,
     sessionId: string,
     status: MeshTaskStatus,
+    opts?: { occurredAt?: string },
 ): MeshWorkQueueEntry | null {
-    const queue = readQueue(meshId);
-    // Collect all assigned tasks for this session, then pick the one with the
-    // most recent dispatchTimestamp (or updatedAt fallback for legacy entries).
-    // This prevents completing the wrong task when multiple tasks were assigned
-    // to the same session in rapid succession.
-    let bestIdx = -1;
-    let bestTime = 0;
-    for (let i = queue.length - 1; i >= 0; i--) {
-        if (queue[i].assignedSessionId === sessionId && queue[i].status === 'assigned') {
+    return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const occurredAtTime = opts?.occurredAt ? new Date(opts.occurredAt).getTime() : Number.NaN;
+        const hasOccurredAt = Number.isFinite(occurredAtTime);
+        let bestIdx = -1;
+        let bestTime = 0;
+        for (let i = queue.length - 1; i >= 0; i--) {
+            if (queue[i].assignedSessionId !== sessionId || queue[i].status !== 'assigned') continue;
             const time = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
-            if (time > bestTime) {
-                bestTime = time;
-                bestIdx = i;
-            }
+            if (hasOccurredAt && Number.isFinite(time) && time > occurredAtTime) continue;
+            if (time > bestTime) { bestTime = time; bestIdx = i; }
         }
-    }
-    if (bestIdx === -1) return null;
-
-    queue[bestIdx].status = status;
-    queue[bestIdx].updatedAt = new Date().toISOString();
-    writeQueue(meshId, queue);
-    return queue[bestIdx];
+        if (bestIdx === -1) return null;
+        queue[bestIdx].status = status;
+        queue[bestIdx].updatedAt = new Date().toISOString();
+        writeQueue(meshId, queue);
+        return queue[bestIdx];
+    });
 }
 
 export interface MeshWorkQueueStats {