@minionry/minion 0.7.36

package/dist/server/services/plan/trigger-evaluator.js

@@ -0,0 +1,211 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const DEFAULT_MAX_CHAIN_DEPTH = 10;
+const DEFAULT_RETRY_ATTEMPTS = 3;
+const DEFAULT_RETRY_BASE_DELAY_MS = 1000;
+const MIN_RETRY_ATTEMPTS = 1;
+const MAX_RETRY_ATTEMPTS = 10;
+const MIN_RETRY_DELAY_MS = 100;
+const MAX_RETRY_DELAY_MS = 60_000;
+export function getDownstreamTriggers(template) {
+    return template?.board?.downstream_triggers ?? [];
+}
+export function evaluateTriggers(triggers, ctx) {
+    const diagnostics = [];
+    const decisions = [];
+    const maxDepth = ctx.maxChainDepth ?? DEFAULT_MAX_CHAIN_DEPTH;
+    for (const trigger of triggers) {
+        if (!trigger.id || !trigger.target_board_id) {
+            diagnostics.push(`Trigger skipped — missing id or target_board_id: ${JSON.stringify(trigger)}`);
+            continue;
+        }
+        const retry = normaliseRetry(trigger.retry);
+        const propagatedChain = [...ctx.chain, trigger.target_board_id];
+        const description = trigger.description
+            ?? `Run ${trigger.target_board_id} after ${ctx.upstreamBoardId}`;
+        const passArtifacts = trigger.pass_artifacts ?? true;
+        if (ctx.chain.includes(trigger.target_board_id)) {
+            decisions.push({
+                triggerId: trigger.id,
+                targetBoardId: trigger.target_board_id,
+                shouldFire: false,
+                skipReason: 'circular_dependency',
+                description,
+                retry,
+                passArtifacts,
+                propagatedChain,
+            });
+            diagnostics.push(`Trigger "${trigger.id}" skipped: target ${trigger.target_board_id} already in chain [${ctx.chain.join(' → ')}]`);
+            continue;
+        }
+        if (propagatedChain.length > maxDepth) {
+            decisions.push({
+                triggerId: trigger.id,
+                targetBoardId: trigger.target_board_id,
+                shouldFire: false,
+                skipReason: 'max_depth_exceeded',
+                description,
+                retry,
+                passArtifacts,
+                propagatedChain,
+            });
+            diagnostics.push(`Trigger "${trigger.id}" skipped: chain depth ${propagatedChain.length} exceeds limit ${maxDepth}`);
+            continue;
+        }
+        const conditionsOk = evaluateConditions(trigger.conditions, ctx, diagnostics, trigger.id);
+        decisions.push({
+            triggerId: trigger.id,
+            targetBoardId: trigger.target_board_id,
+            shouldFire: conditionsOk,
+            skipReason: conditionsOk ? undefined : 'condition_not_met',
+            description,
+            retry,
+            passArtifacts,
+            propagatedChain,
+        });
+    }
+    return { decisions, diagnostics };
+}
+export function computeRetryDelayMs(retry, attempt) {
+    const safeAttempt = Math.max(0, attempt);
+    const raw = retry.baseDelayMs * 2 ** safeAttempt;
+    if (raw <= MIN_RETRY_DELAY_MS)
+        return MIN_RETRY_DELAY_MS;
+    if (raw >= MAX_RETRY_DELAY_MS)
+        return MAX_RETRY_DELAY_MS;
+    return Math.round(raw);
+}
+export function detectCircularDependencies(graph) {
+    const cycles = [];
+    const seenCycles = new Set();
+    const visiting = new Set();
+    const visited = new Set();
+    function walk(node, stack) {
+        if (visiting.has(node)) {
+            const cycleStart = stack.indexOf(node);
+            if (cycleStart >= 0) {
+                const cycle = stack.slice(cycleStart);
+                cycle.push(node);
+                const key = canonicaliseCycleKey(cycle.slice(0, -1));
+                if (!seenCycles.has(key)) {
+                    seenCycles.add(key);
+                    cycles.push(cycle);
+                }
+            }
+            return;
+        }
+        if (visited.has(node))
+            return;
+        visiting.add(node);
+        stack.push(node);
+        const targets = graph.get(node) ?? [];
+        for (const target of targets)
+            walk(target, stack);
+        stack.pop();
+        visiting.delete(node);
+        visited.add(node);
+    }
+    for (const node of graph.keys()) {
+        if (visited.has(node))
+            continue;
+        walk(node, []);
+    }
+    return { hasCycle: cycles.length > 0, cycles };
+}
+function canonicaliseCycleKey(nodes) {
+    if (nodes.length === 0)
+        return '';
+    let bestIdx = 0;
+    for (let i = 1; i < nodes.length; i++) {
+        if (nodes[i] < nodes[bestIdx])
+            bestIdx = i;
+    }
+    const rotated = [...nodes.slice(bestIdx), ...nodes.slice(0, bestIdx)];
+    return rotated.join('|');
+}
+export function buildTriggerGraph(templates) {
+    const graph = new Map();
+    for (const template of templates) {
+        const triggers = getDownstreamTriggers(template);
+        const targets = triggers
+            .map((t) => t.target_board_id)
+            .filter((id) => typeof id === 'string' && id.length > 0);
+        graph.set(template.template_id, targets);
+        for (const target of targets) {
+            if (!graph.has(target))
+                graph.set(target, []);
+        }
+    }
+    return graph;
+}
+function normaliseRetry(retry) {
+    const rawAttempts = retry?.max_attempts ?? DEFAULT_RETRY_ATTEMPTS;
+    const rawDelay = retry?.base_delay_ms ?? DEFAULT_RETRY_BASE_DELAY_MS;
+    return {
+        maxAttempts: clamp(Number.isFinite(rawAttempts) ? Math.floor(rawAttempts) : DEFAULT_RETRY_ATTEMPTS, MIN_RETRY_ATTEMPTS, MAX_RETRY_ATTEMPTS),
+        baseDelayMs: clamp(Number.isFinite(rawDelay) ? Math.floor(rawDelay) : DEFAULT_RETRY_BASE_DELAY_MS, MIN_RETRY_DELAY_MS, MAX_RETRY_DELAY_MS),
+    };
+}
+function clamp(value, min, max) {
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return value;
+}
+function evaluateConditions(conditions, ctx, diagnostics, triggerId) {
+    if (!conditions || conditions.length === 0) {
+        return ctx.upstreamStatus === 'completed';
+    }
+    for (const condition of conditions) {
+        if (!conditionMatches(condition, ctx, diagnostics, triggerId))
+            return false;
+    }
+    return true;
+}
+function conditionMatches(condition, ctx, diagnostics, triggerId) {
+    switch (condition.type) {
+        case 'on_success':
+            return ctx.upstreamStatus === 'completed';
+        case 'on_failure':
+            return ctx.upstreamStatus === 'failed' || ctx.upstreamStatus === 'cancelled';
+        case 'on_complete':
+            return ctx.upstreamStatus !== 'failed' && ctx.upstreamStatus !== 'cancelled';
+        case 'on_artifact':
+            return hasMatchingArtifact(ctx.artifacts, condition.file_pattern);
+        case 'artifact_contains': {
+            if (!condition.contains || condition.contains.length === 0) {
+                diagnostics.push(`Trigger "${triggerId}" has artifact_contains condition without \`contains\` — treated as false`);
+                return false;
+            }
+            return artifactContains(ctx.artifacts, condition.contains, condition.file_pattern);
+        }
+        default: {
+            diagnostics.push(`Trigger "${triggerId}" has unknown condition type "${condition.type}" — treated as false`);
+            return false;
+        }
+    }
+}
+function hasMatchingArtifact(artifacts, filePattern) {
+    if (artifacts.length === 0)
+        return false;
+    if (!filePattern)
+        return true;
+    const matcher = compilePatternRegex(filePattern);
+    return artifacts.some((a) => matcher.test(a.fileName));
+}
+function artifactContains(artifacts, needle, filePattern) {
+    const lowerNeedle = needle.toLowerCase();
+    const matcher = filePattern ? compilePatternRegex(filePattern) : null;
+    for (const artifact of artifacts) {
+        if (matcher && !matcher.test(artifact.fileName))
+            continue;
+        if (artifact.content.toLowerCase().includes(lowerNeedle))
+            return true;
+    }
+    return false;
+}
+function compilePatternRegex(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`, 'i');
+}

package/dist/server/services/plan/types.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const MAX_REVIEW_ATTEMPTS = 3;

package/dist/server/services/plan/watcher.js

@@ -0,0 +1,73 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { watch } from 'node:fs';
+import { parsePlanDirectory, resolvePmDir } from './parser.js';
+export class PlanWatcher {
+    watcher = null;
+    debounceTimer = null;
+    workingDir;
+    ctx;
+    started = false;
+    updateListeners = new Set();
+    constructor(workingDir, ctx) {
+        this.workingDir = workingDir;
+        this.ctx = ctx;
+    }
+    start() {
+        if (this.started)
+            return;
+        const planDir = resolvePmDir(this.workingDir);
+        if (!planDir)
+            return;
+        try {
+            this.watcher = watch(planDir, { recursive: true }, (_event, filename) => {
+                if (!filename?.endsWith('.md'))
+                    return;
+                this.debounce();
+            });
+            this.started = true;
+        }
+        catch {
+        }
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.started = false;
+    }
+    debounce() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.handleChange();
+        }, 200);
+    }
+    onUpdate(listener) {
+        this.updateListeners.add(listener);
+        return () => this.updateListeners.delete(listener);
+    }
+    handleChange() {
+        try {
+            const fullState = parsePlanDirectory(this.workingDir);
+            if (fullState) {
+                this.ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+                for (const listener of this.updateListeners) {
+                    try {
+                        listener();
+                    }
+                    catch (error) {
+                        console.error('[PlanWatcher] update listener threw:', error);
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
+}

package/dist/server/services/platform-credentials.js

@@ -0,0 +1,56 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { machineFile } from '../../bin/machine-layout.js';
+import { writeFileAtomic } from '../utils/file-store.js';
+import { MINIONRY_ROOT } from '../utils/paths.js';
+export const CLI_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(join(MINIONRY_ROOT, 'package.json'), 'utf-8'));
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
+function credentialsFile() {
+    const env = process.env.MINIONRY_ENV || 'production';
+    return machineFile(env === 'dev' ? 'platformCredentialsDev' : 'platformCredentials');
+}
+export const TOKEN_REFRESH_INTERVAL_MS = 30 * 24 * 60 * 60 * 1000;
+export const TOKEN_VERSION = 2;
+export function getCredentials() {
+    if (!existsSync(credentialsFile())) {
+        return null;
+    }
+    try {
+        const content = readFileSync(credentialsFile(), 'utf-8');
+        const creds = JSON.parse(content);
+        if (creds.token && creds.userId && creds.email) {
+            if (typeof creds.tokenVersion === 'number' && creds.tokenVersion < TOKEN_VERSION) {
+                return null;
+            }
+            return creds;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function updateCredentials(updates) {
+    const creds = getCredentials();
+    if (!creds)
+        return;
+    const next = { ...creds, ...updates, tokenVersion: TOKEN_VERSION };
+    writeFileAtomic(credentialsFile(), JSON.stringify(next, null, 2), { mode: 0o600 });
+}
+export function shouldRefreshToken(creds) {
+    if (!creds.lastRefreshedAt) {
+        return true;
+    }
+    const lastRefreshed = new Date(creds.lastRefreshedAt).getTime();
+    const now = Date.now();
+    return now - lastRefreshed > TOKEN_REFRESH_INTERVAL_MS;
+}