@minionry/minion 0.7.36

package/dist/server/engines/types.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export class EngineStartError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'EngineStartError';
+    }
+}
+export class AppRunUnsupportedError extends EngineStartError {
+    engineId;
+    constructor(engineId, reason) {
+        super('APP_RUN_UNSUPPORTED', `${engineId} cannot run an app session: ${reason}`);
+        this.engineId = engineId;
+        this.name = 'AppRunUnsupportedError';
+    }
+}
+export function supportsQuestions(engine) {
+    const candidate = engine;
+    return (typeof candidate.answerQuestion === 'function' &&
+        typeof candidate.rejectQuestion === 'function');
+}
+export function reportsNativeResume(engine) {
+    return typeof engine.resumedNatively === 'boolean';
+}
+export { CLAUDE_MODEL_PRESETS, CODEX_MODEL_IDS, CODEX_MODEL_PRESETS, ENGINE_EFFORT_LEVELS, ENGINE_IDS, engineForModel, isEngineId, isMessageEvent, isToolEvent, parseEngineId, } from './EngineEvent.js';

package/dist/server/handlers/company-execution-registry.js

@@ -0,0 +1,67 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const QUEUED_DRAIN_NOTICE_TTL_MS = 5 * 60 * 1000;
+export class CompanyExecutionRegistry {
+    executions = new Map();
+    pausedCompanies = new Map();
+    queuedDrainNoticeAt = new Map();
+    get(executionId) {
+        return this.executions.get(executionId);
+    }
+    has(executionId) {
+        return this.executions.has(executionId);
+    }
+    set(executionId, state) {
+        this.executions.set(executionId, state);
+    }
+    delete(executionId) {
+        this.executions.delete(executionId);
+    }
+    values() {
+        return this.executions.values();
+    }
+    snapshotValues() {
+        return Array.from(this.executions.values());
+    }
+    activeIds() {
+        return Array.from(this.executions.keys());
+    }
+    getPause(companyId) {
+        return this.pausedCompanies.get(companyId);
+    }
+    setPause(companyId, reason) {
+        this.pausedCompanies.set(companyId, reason);
+    }
+    deletePause(companyId) {
+        return this.pausedCompanies.delete(companyId);
+    }
+    pausedSnapshot() {
+        return Object.fromEntries(this.pausedCompanies);
+    }
+    shouldEmitDrainNotice(companyId, now) {
+        const last = this.queuedDrainNoticeAt.get(companyId);
+        if (last !== undefined && now - last < QUEUED_DRAIN_NOTICE_TTL_MS)
+            return false;
+        this.queuedDrainNoticeAt.set(companyId, now);
+        return true;
+    }
+    reset() {
+        for (const state of this.executions.values()) {
+            try {
+                state.progressThrottle.cancel();
+                state.metricsThrottle.cancel();
+                for (const throttle of state.outputThrottles.values()) {
+                    throttle.cancel();
+                }
+                state.outputThrottles.clear();
+                state.executor.removeAllListeners();
+                state.executor.stop();
+            }
+            catch {
+            }
+        }
+        this.executions.clear();
+        this.pausedCompanies.clear();
+        this.queuedDrainNoticeAt.clear();
+    }
+}

package/dist/server/handlers/company-handlers.js

@@ -0,0 +1,514 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { PlanExecutor } from '../services/plan/executor.js';
+import { parseBoardDirectory, resolvePmDir } from '../services/plan/parser.js';
+import { instantiateTemplate, loadTemplate } from '../services/plan/template-instantiator.js';
+import { companyMessages, isCompanyInboundMessageType, validateCompanyInboundData, } from '../types/company-messages.js';
+import { CompanyExecutionRegistry } from './company-execution-registry.js';
+import { fireDownstreamTriggers } from './company-triggers.js';
+const THROTTLE_INTERVAL_MS = 1000;
+function createThrottle(emit, coalesce = (_prev, next) => next) {
+    let lastEmittedAt = 0;
+    let pending = null;
+    let timer = null;
+    function doEmit(value) {
+        lastEmittedAt = Date.now();
+        emit(value);
+    }
+    function flush() {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        if (pending !== null) {
+            const { value } = pending;
+            pending = null;
+            doEmit(value);
+        }
+    }
+    function enqueue(value) {
+        const now = Date.now();
+        const elapsed = now - lastEmittedAt;
+        if (elapsed >= THROTTLE_INTERVAL_MS && timer === null && pending === null) {
+            doEmit(value);
+            return;
+        }
+        pending = pending === null ? { value } : { value: coalesce(pending.value, value) };
+        if (timer === null) {
+            const delay = Math.max(0, THROTTLE_INTERVAL_MS - elapsed);
+            timer = setTimeout(() => {
+                timer = null;
+                flush();
+            }, delay);
+        }
+    }
+    function cancel() {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        pending = null;
+    }
+    return { enqueue, flush, cancel };
+}
+const registry = new CompanyExecutionRegistry();
+const BUDGET_RESUME_REASON = '__minionry_budget_resume__';
+export function handleCompanyMessage(ctx, ws, msg, _tabId, workingDir, permission) {
+    if (!isCompanyInboundMessageType(msg.type)) {
+        ctx.send(ws, companyMessages.error({ error: `Unknown company message type: ${msg.type}` }));
+        return;
+    }
+    try {
+        validateCompanyInboundData(msg.type, msg.data);
+    }
+    catch (error) {
+        ctx.send(ws, companyMessages.error({
+            error: error instanceof Error ? error.message : String(error),
+            executionId: msg.data?.executionId,
+        }));
+        return;
+    }
+    if (permission === 'view' && msg.type !== 'companyGetExecutionStatus') {
+        ctx.send(ws, companyMessages.error({
+            error: 'Permission denied',
+            executionId: msg.data?.executionId,
+            companyId: msg.data?.companyId,
+        }));
+        return;
+    }
+    try {
+        dispatchCompany(ctx, ws, msg.type, msg.data, workingDir);
+    }
+    catch (error) {
+        ctx.send(ws, companyMessages.error({
+            error: error instanceof Error ? error.message : String(error),
+            executionId: msg.data?.executionId,
+            companyId: msg.data?.companyId,
+        }));
+    }
+}
+function dispatchCompany(ctx, ws, type, 
+data, workingDir) {
+    switch (type) {
+        case 'companyExecuteBoard':
+            handleExecuteBoard(ctx, ws, data, workingDir);
+            return;
+        case 'companyPauseExecution':
+            handlePause(ctx, ws, data);
+            return;
+        case 'companyResumeExecution':
+            handleResume(ctx, ws, data);
+            return;
+        case 'companyStopExecution':
+            handleStop(ctx, ws, data);
+            return;
+        case 'companyGetExecutionStatus':
+            handleGetStatus(ctx, ws, data);
+            return;
+        case 'companyEmergencyStop': {
+            const stopData = data;
+            if (stopData.reason === BUDGET_RESUME_REASON) {
+                clearBudgetPause(stopData.companyId);
+                return;
+            }
+            handleEmergencyStop(ctx, stopData.companyId, stopData.reason);
+            return;
+        }
+    }
+}
+function handleExecuteBoard(ctx, ws, data, workingDir) {
+    const pauseReason = registry.getPause(data.companyId);
+    if (pauseReason !== undefined) {
+        ctx.broadcastToAll(companyMessages.executionError({
+            executionId: data.executionId,
+            error: `Budget exceeded: company is paused (${pauseReason || 'budget cap reached'})`,
+        }));
+        sendToOrigin(ctx, ws, companyMessages.error({
+            error: `Budget exceeded: company ${data.companyId} is paused (${pauseReason || 'budget cap reached'})`,
+            executionId: data.executionId,
+            companyId: data.companyId,
+        }));
+        return false;
+    }
+    if (registry.has(data.executionId)) {
+        sendToOrigin(ctx, ws, companyMessages.error({
+            error: `Execution already active: ${data.executionId}`,
+            executionId: data.executionId,
+            companyId: data.companyId,
+        }));
+        return false;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        sendToOrigin(ctx, ws, companyMessages.executionError({
+            executionId: data.executionId,
+            error: `No .minionry/specs directory found at ${workingDir}`,
+        }));
+        return false;
+    }
+    const boardId = data.departmentBoardId;
+    const boardDir = join(pmDir, 'boards', boardId);
+    if (!existsSync(boardDir)) {
+        try {
+            ensureBoardFromTemplate(pmDir, boardId);
+        }
+        catch (error) {
+            sendToOrigin(ctx, ws, companyMessages.executionError({
+                executionId: data.executionId,
+                error: `Board ${boardId} not found and template instantiation failed: ${error instanceof Error ? error.message : String(error)}`,
+            }));
+            return false;
+        }
+    }
+    const issuesTotal = countBoardIssues(pmDir, boardId);
+    const executor = new PlanExecutor(workingDir);
+    const triggerChain = data.upstreamContext
+        ? [...data.upstreamContext.chain, boardId]
+        : [boardId];
+    const state = {
+        executor,
+        executionId: data.executionId,
+        companyId: data.companyId,
+        departmentId: data.departmentId,
+        boardId,
+        workingDir,
+        trigger: data.trigger,
+        riskTolerance: data.riskTolerance,
+        budgetRemainingCents: data.budgetRemainingCents,
+        startedAt: Date.now(),
+        issuesTotal,
+        finalized: false,
+        triggerChain,
+        upstreamContext: data.upstreamContext,
+        pendingApprovals: new Set(),
+        progressThrottle: createThrottle((payload) => {
+            ctx.broadcastToAll(companyMessages.executionProgress(payload));
+        }),
+        metricsThrottle: createThrottle((payload) => {
+            ctx.broadcastToAll(companyMessages.executionMetrics(payload));
+        }),
+        outputThrottles: new Map(),
+    };
+    registry.set(data.executionId, state);
+    wireExecutorEvents(ctx, state);
+    ctx.broadcastToAll(companyMessages.executionStarted({
+        executionId: state.executionId,
+        companyId: state.companyId,
+        departmentId: state.departmentId,
+        boardId: state.boardId,
+        startedAt: new Date(state.startedAt).toISOString(),
+    }));
+    ctx.broadcastToAll(companyMessages.executionProgress({
+        executionId: state.executionId,
+        currentIssueId: null,
+        issuesCompleted: 0,
+        issuesTotal: state.issuesTotal,
+        currentWaveIds: [],
+    }));
+    executor.startBoard(boardId).catch((error) => {
+        emitExecutionError(ctx, state, error instanceof Error ? error.message : String(error));
+        finalizeExecution(ctx, state, 'failed');
+    });
+    return true;
+}
+function sendToOrigin(ctx, ws, msg) {
+    if (!ws)
+        return;
+    ctx.send(ws, msg);
+}
+function isScheduleFireData(value) {
+    if (value == null || typeof value !== 'object')
+        return false;
+    const d = value;
+    const queuedOk = d.queued === undefined || typeof d.queued === 'boolean';
+    return (typeof d.scheduleId === 'string' && d.scheduleId.length > 0 &&
+        typeof d.companyId === 'string' && d.companyId.length > 0 &&
+        typeof d.departmentId === 'string' && d.departmentId.length > 0 &&
+        typeof d.boardTemplateId === 'string' && d.boardTemplateId.length > 0 &&
+        typeof d.firedAt === 'string' && d.firedAt.length > 0 &&
+        queuedOk);
+}
+function emitQueuedDrainNoticeOnce(ctx, companyId, firedAt) {
+    if (!registry.shouldEmitDrainNotice(companyId, Date.now()))
+        return;
+    ctx.broadcastToAll(companyMessages.error({
+        error: `Queued trigger recovery: replaying scheduled runs missed while CLI was offline (first due at ${firedAt})`,
+        companyId,
+    }));
+}
+export function handleScheduleFire(ctx, ws, rawData, workingDir) {
+    if (!isScheduleFireData(rawData)) {
+        ctx.send(ws, companyMessages.error({
+            error: 'scheduleFire: invalid payload',
+        }));
+        return;
+    }
+    const data = rawData;
+    if (data.queued) {
+        console.log(`[CompanyHandlers] Replaying queued scheduleFire: schedule=${data.scheduleId} ` +
+            `company=${data.companyId} dueAt=${data.firedAt}`);
+        emitQueuedDrainNoticeOnce(ctx, data.companyId, data.firedAt);
+    }
+    const executionId = `sched-${data.scheduleId}-${Date.parse(data.firedAt) || randomUUID()}`;
+    const executeBoardData = {
+        companyId: data.companyId,
+        departmentId: data.departmentId,
+        departmentBoardId: data.boardTemplateId,
+        executionId,
+        trigger: 'scheduled',
+        budgetRemainingCents: 0,
+        riskTolerance: 'balanced',
+    };
+    handleExecuteBoard(ctx, ws, executeBoardData, workingDir);
+}
+function ensureBoardFromTemplate(pmDir, boardId) {
+    const templatePath = join(pmDir, 'templates', `${boardId}.json`);
+    if (!existsSync(templatePath)) {
+        throw new Error(`Board ${boardId} does not exist and no template at ${templatePath}`);
+    }
+    const template = loadTemplate(templatePath);
+    instantiateTemplate(template, { pmDir, boardId, failIfExists: true });
+}
+function countBoardIssues(pmDir, boardId) {
+    const state = parseBoardDirectory(pmDir, boardId);
+    if (!state)
+        return 0;
+    return state.issues.filter((i) => i.type !== 'epic').length;
+}
+function wireExecutorEvents(ctx, state) {
+    const { executor } = state;
+    executor.removeAllListeners();
+    executor.on('waveStarted', (data) => {
+        emitProgress(ctx, state, { currentWaveIds: data.issueIds });
+    });
+    executor.on('output', (data) => {
+        enqueueOutput(ctx, state, data.issueId, { text: data.text, kind: 'text' });
+    });
+    executor.on('issueCompleted', () => {
+        const m = executor.getMetrics();
+        emitProgress(ctx, state, {
+            currentIssueId: m.currentIssueId,
+            issuesCompleted: m.issuesCompleted,
+            currentWaveIds: m.currentWaveIds,
+        });
+        emitMetrics(ctx, state);
+    });
+    executor.on('issueError', (data) => {
+        ctx.broadcastToAll(companyMessages.executionError({
+            executionId: state.executionId,
+            error: data.error,
+            issueId: data.issueId,
+        }));
+    });
+    executor.on('waveError', (data) => {
+        ctx.broadcastToAll(companyMessages.executionError({
+            executionId: state.executionId,
+            error: `Wave [${data.issueIds.join(', ')}]: ${data.error}`,
+        }));
+    });
+    executor.on('statusChanged', (status) => {
+        if (status === 'paused' || status === 'stopping' || status === 'executing') {
+            emitProgress(ctx, state, {});
+        }
+    });
+    executor.on('complete', () => {
+        finalizeExecution(ctx, state, deriveTerminalStatus(executor.getStatus(), state));
+        ctx.commitSuggestions?.notifyExecutionSettled(state.workingDir);
+    });
+    executor.on('error', (error) => {
+        emitExecutionError(ctx, state, error);
+        finalizeExecution(ctx, state, 'failed');
+        ctx.commitSuggestions?.notifyExecutionSettled(state.workingDir);
+    });
+}
+function emitProgress(_ctx, state, overrides) {
+    const m = state.executor.getMetrics();
+    state.progressThrottle.enqueue({
+        executionId: state.executionId,
+        currentIssueId: overrides.currentIssueId ?? m.currentIssueId,
+        issuesCompleted: overrides.issuesCompleted ?? m.issuesCompleted,
+        issuesTotal: overrides.issuesTotal ?? state.issuesTotal,
+        currentWaveIds: overrides.currentWaveIds ?? m.currentWaveIds,
+    });
+}
+function emitMetrics(_ctx, state) {
+    const m = state.executor.getMetrics();
+    state.metricsThrottle.enqueue({
+        executionId: state.executionId,
+        tokensUsed: 0,
+        costMicrocents: 0,
+        duration: Date.now() - state.startedAt,
+    });
+    void m;
+}
+function enqueueOutput(ctx, state, issueId, payload) {
+    let throttle = state.outputThrottles.get(issueId);
+    if (!throttle) {
+        throttle = createThrottle((value) => {
+            ctx.broadcastToAll(companyMessages.executionOutput({
+                executionId: state.executionId,
+                issueId,
+                output: value.text,
+                type: value.kind,
+            }));
+        }, 
+        (prev, next) => ({
+            text: prev.text + next.text,
+            kind: prev.kind === next.kind ? prev.kind : next.kind,
+        }));
+        state.outputThrottles.set(issueId, throttle);
+    }
+    throttle.enqueue(payload);
+}
+function emitExecutionError(ctx, state, error) {
+    ctx.broadcastToAll(companyMessages.executionError({
+        executionId: state.executionId,
+        error,
+    }));
+}
+function deriveTerminalStatus(executorStatus, state) {
+    if (executorStatus === 'error')
+        return 'failed';
+    if (executorStatus === 'idle' || executorStatus === 'paused')
+        return 'cancelled';
+    const m = state.executor.getMetrics();
+    if (state.issuesTotal > 0 && m.issuesCompleted < state.issuesTotal)
+        return 'partial';
+    return 'completed';
+}
+function finalizeExecution(ctx, state, status) {
+    if (state.finalized)
+        return;
+    state.finalized = true;
+    state.progressThrottle.flush();
+    state.metricsThrottle.flush();
+    for (const throttle of state.outputThrottles.values()) {
+        throttle.flush();
+    }
+    state.outputThrottles.clear();
+    const m = state.executor.getMetrics();
+    const issuesFailed = Math.max(0, m.issuesAttempted - m.issuesCompleted);
+    ctx.broadcastToAll(companyMessages.executionComplete({
+        executionId: state.executionId,
+        status,
+        issuesCompleted: m.issuesCompleted,
+        issuesFailed,
+        artifacts: [],
+        tokensUsed: 0,
+        costMicrocents: 0,
+        durationMs: Date.now() - state.startedAt,
+    }));
+    state.executor.removeAllListeners();
+    registry.delete(state.executionId);
+    void fireDownstreamTriggers(ctx, state, status, (payload, workingDir) => handleExecuteBoard(ctx, null, payload, workingDir));
+}
+function withExecution(ctx, ws, executionId, fn) {
+    const state = registry.get(executionId);
+    if (!state) {
+        ctx.send(ws, companyMessages.error({ error: `Execution not found: ${executionId}`, executionId }));
+        return;
+    }
+    fn(state);
+}
+function handlePause(ctx, ws, data) {
+    withExecution(ctx, ws, data.executionId, (state) => {
+        state.executor.pause();
+    });
+}
+function handleResume(ctx, ws, data) {
+    withExecution(ctx, ws, data.executionId, (state) => {
+        if (state.pendingApprovals.size > 0) {
+            ctx.send(ws, companyMessages.error({
+                error: `Execution blocked on ${state.pendingApprovals.size} pending approval${state.pendingApprovals.size === 1 ? '' : 's'}`,
+                executionId: data.executionId,
+            }));
+            return;
+        }
+        state.executor.resume().catch((error) => {
+            emitExecutionError(ctx, state, error instanceof Error ? error.message : String(error));
+        });
+    });
+}
+export function registerPendingApproval(executionId, approvalId) {
+    const state = registry.get(executionId);
+    if (!state)
+        return false;
+    state.pendingApprovals.add(approvalId);
+    try {
+        state.executor.pause();
+    }
+    catch {
+    }
+    return true;
+}
+export function resolveApproval(executionId, approvalId, decision) {
+    const state = registry.get(executionId);
+    if (!state)
+        return 'unknown';
+    state.pendingApprovals.delete(approvalId);
+    if (decision === 'rejected') {
+    }
+    if (state.pendingApprovals.size > 0)
+        return 'still-blocked';
+    state.executor.resume().catch((error) => {
+        void error;
+    });
+    return 'resumed';
+}
+function handleStop(ctx, ws, data) {
+    withExecution(ctx, ws, data.executionId, (state) => {
+        state.executor.stop();
+        finalizeExecution(ctx, state, 'cancelled');
+    });
+}
+export function handleEmergencyStop(ctx, companyId, reason) {
+    if (!companyId)
+        return 0;
+    registry.setPause(companyId, reason ?? '');
+    let stopped = 0;
+    const stopMessage = reason
+        ? `Emergency pause: all running executions for this company have been cancelled (${reason})`
+        : 'Emergency pause: all running executions for this company have been cancelled';
+    for (const state of registry.snapshotValues()) {
+        if (state.companyId !== companyId)
+            continue;
+        try {
+            state.executor.stop();
+        }
+        catch {
+        }
+        emitExecutionError(ctx, state, stopMessage);
+        finalizeExecution(ctx, state, 'cancelled');
+        stopped += 1;
+    }
+    return stopped;
+}
+export function clearBudgetPause(companyId) {
+    if (!companyId)
+        return false;
+    return registry.deletePause(companyId);
+}
+export function __getPausedCompanies() {
+    return registry.pausedSnapshot();
+}
+function handleGetStatus(ctx, ws, data) {
+    withExecution(ctx, ws, data.executionId, (state) => {
+        const m = state.executor.getMetrics();
+        ctx.send(ws, companyMessages.executionProgress({
+            executionId: state.executionId,
+            currentIssueId: m.currentIssueId,
+            issuesCompleted: m.issuesCompleted,
+            issuesTotal: state.issuesTotal,
+            currentWaveIds: m.currentWaveIds,
+        }));
+    });
+}
+export function __getActiveExecutionIds() {
+    return registry.activeIds();
+}
+export function __resetExecutions() {
+    registry.reset();
+}