@minionry/minion 0.7.36

package/dist/server/services/sdk/pm-execute.js

@@ -0,0 +1,228 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { isBoardPlanning } from '../plan/composer.js';
+import { logAppAudit } from './audit.js';
+import { getGrant } from './grant-store.js';
+import { registerLiveSubscription } from './live-registry.js';
+import { readBoardSnapshot } from './pm.js';
+import { getPlanningTap } from './pm-planning-tap.js';
+import { SdkMethodError } from './registry.js';
+let executionHost = null;
+export function setSdkPmExecutionHost(host) {
+    executionHost = host;
+}
+export function resetSdkPmExecutionHost() {
+    executionHost = null;
+}
+function requireExecutionHost(method) {
+    if (!executionHost) {
+        throw new SdkMethodError('INTERNAL', `'${method}' host is not wired — the WebSocket handler installs it at startup`);
+    }
+    return executionHost;
+}
+const planningRunIds = new Map();
+function planningBoardKey(workingDir, boardId) {
+    return `${workingDir}::${boardId}`;
+}
+function planningRunId(workingDir, boardId) {
+    const key = planningBoardKey(workingDir, boardId);
+    let runId = planningRunIds.get(key);
+    if (!runId) {
+        runId = `boardrun-plan-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        planningRunIds.set(key, runId);
+    }
+    return runId;
+}
+export function resetSdkPmExecuteRuns() {
+    planningRunIds.clear();
+}
+const RAW_EXECUTOR_EVENTS = [
+    'issueStarted',
+    'output',
+    'tokenUsage',
+    'toolUse',
+    'reviewProgress',
+    'issueCompleted',
+    'complete',
+    'error',
+];
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function translateExecutorEvent(event, payload) {
+    const raw = asRecord(payload);
+    switch (event) {
+        case 'issueStarted': {
+            const issueId = str(raw.id);
+            return issueId ? { event: 'issueStarted', payload: { issueId, title: str(raw.title) } } : null;
+        }
+        case 'output': {
+            const issueId = str(raw.issueId);
+            const text = str(raw.text);
+            return issueId && text ? { event: 'output', payload: { issueId, text } } : null;
+        }
+        case 'tokenUsage': {
+            const issueId = str(raw.issueId);
+            if (!issueId)
+                return null;
+            const usage = asRecord(raw.usage);
+            return {
+                event: 'tokens',
+                payload: {
+                    issueId,
+                    inputTokens: num(usage.inputTokens),
+                    outputTokens: num(usage.outputTokens),
+                    cacheCreationTokens: num(usage.cacheCreationTokens),
+                    cacheReadTokens: num(usage.cacheReadTokens),
+                    currentTurnInputTokens: num(usage.currentTurnInputTokens),
+                    isFinal: usage.isFinal === true,
+                },
+            };
+        }
+        case 'toolUse': {
+            const issueId = str(raw.issueId);
+            const toolEvent = asRecord(raw.event);
+            if (!issueId || toolEvent.type !== 'tool_complete' || typeof toolEvent.toolName !== 'string')
+                return null;
+            return {
+                event: 'toolUse',
+                payload: {
+                    issueId,
+                    tool: toolEvent.toolName,
+                    ...(toolEvent.completeInput !== undefined ? { input: toolEvent.completeInput } : {}),
+                },
+            };
+        }
+        case 'reviewProgress': {
+            const issueId = str(raw.issueId);
+            return issueId ? { event: 'reviewProgress', payload: { issueId, status: str(raw.status) } } : null;
+        }
+        case 'issueCompleted': {
+            const issueId = str(raw.id);
+            return issueId ? { event: 'issueComplete', payload: { issueId } } : null;
+        }
+        case 'complete':
+            return { event: 'complete', payload: { reason: typeof payload === 'string' ? payload : '' } };
+        case 'error':
+            return { event: 'complete', payload: { reason: typeof payload === 'string' ? payload : 'execution error' } };
+        default:
+            return null;
+    }
+}
+function paramsObject(params) {
+    return typeof params === 'object' && params !== null && !Array.isArray(params)
+        ? params
+        : {};
+}
+function parseBoardIdParams(params, method) {
+    const raw = paramsObject(params);
+    if (typeof raw.boardId !== 'string' || raw.boardId.trim() === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${method} requires params { boardId }`);
+    }
+    return raw.boardId;
+}
+function boardNotFound(boardId) {
+    return new SdkMethodError('BAD_REQUEST', `board '${boardId}' not found in this Space`);
+}
+function requireBoard(workingDir, boardId) {
+    if (!readBoardSnapshot(workingDir, boardId))
+        throw boardNotFound(boardId);
+}
+function attachTranslatedStream(args, source, events, translate) {
+    const listeners = [];
+    for (const event of events) {
+        const cb = (payload) => {
+            const translated = translate(event, payload);
+            if (translated)
+                args.emit(translated.event, translated.payload);
+        };
+        source.on(event, cb);
+        listeners.push([event, cb]);
+    }
+    registerLiveSubscription({
+        requestId: args.requestId,
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        kind: 'pm.execute',
+        viewerId: getGrant(args.appId, args.spaceKey) ? undefined : args.viewerId,
+        teardown: () => {
+            for (const [event, cb] of listeners)
+                source.off(event, cb);
+        },
+    });
+}
+export function pmExecuteHandler(args) {
+    const boardId = parseBoardIdParams(args.params, args.method);
+    requireBoard(args.workingDir, boardId);
+    if (isBoardPlanning(args.workingDir, boardId)) {
+        const runId = planningRunId(args.workingDir, boardId);
+        attachTranslatedStream(args, getPlanningTap(args.workingDir, boardId), ['issueStarted', 'output', 'tokens', 'toolUse', 'reviewProgress', 'issueComplete', 'complete'], 
+        (event, payload) => ({ event, payload }));
+        logAppAudit({
+            appId: args.appId,
+            origin: args.origin,
+            method: 'pm.execute',
+            decision: 'allow',
+            requestId: args.requestId,
+            spaceKey: args.spaceKey,
+            reason: `attached to board ${boardId}'s planning run (runId ${runId})`,
+        });
+        return { runId };
+    }
+    const host = requireExecutionHost(args.method);
+    let handle;
+    try {
+        handle = host.attach(args.workingDir, boardId);
+    }
+    catch (error) {
+        throw new SdkMethodError('BAD_REQUEST', error instanceof Error ? error.message : String(error));
+    }
+    attachTranslatedStream(args, handle, RAW_EXECUTOR_EVENTS, translateExecutorEvent);
+    logAppAudit({
+        appId: args.appId,
+        origin: args.origin,
+        method: 'pm.execute',
+        decision: 'allow',
+        requestId: args.requestId,
+        spaceKey: args.spaceKey,
+        reason: `attached to board ${boardId}'s execution run (runId ${handle.runId})`,
+    });
+    return { runId: handle.runId };
+}
+function parseControlParams(params, method) {
+    return parseBoardIdParams(params, method);
+}
+function planningControlUnsupported(method, boardId) {
+    return new SdkMethodError('BAD_REQUEST', `${method}: board '${boardId}' is still planning — pause/resume/stop apply to the implementation run only`);
+}
+export function pmPauseHandler(args) {
+    const boardId = parseControlParams(args.params, args.method);
+    requireBoard(args.workingDir, boardId);
+    if (isBoardPlanning(args.workingDir, boardId))
+        throw planningControlUnsupported('pm.pause', boardId);
+    requireExecutionHost(args.method).pause(args.workingDir, boardId);
+    return null;
+}
+export async function pmResumeHandler(args) {
+    const boardId = parseControlParams(args.params, args.method);
+    requireBoard(args.workingDir, boardId);
+    if (isBoardPlanning(args.workingDir, boardId))
+        throw planningControlUnsupported('pm.resume', boardId);
+    await requireExecutionHost(args.method).resume(args.workingDir, boardId);
+    return null;
+}
+export function pmStopHandler(args) {
+    const boardId = parseControlParams(args.params, args.method);
+    requireBoard(args.workingDir, boardId);
+    if (isBoardPlanning(args.workingDir, boardId))
+        throw planningControlUnsupported('pm.stop', boardId);
+    requireExecutionHost(args.method).stop(args.workingDir, boardId);
+    return null;
+}

package/dist/server/services/sdk/pm-planning-tap.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { EventEmitter } from 'node:events';
+function planningTapKey(workingDir, boardId) {
+    return `${workingDir}::${boardId}`;
+}
+const taps = new Map();
+export function getPlanningTap(workingDir, boardId) {
+    const key = planningTapKey(workingDir, boardId);
+    let emitter = taps.get(key);
+    if (!emitter) {
+        emitter = new EventEmitter();
+        taps.set(key, emitter);
+    }
+    return emitter;
+}
+export function emitPlanningTap(workingDir, boardId, event, payload) {
+    taps.get(planningTapKey(workingDir, boardId))?.emit(event, payload);
+}
+export function clearPlanningTap(workingDir, boardId) {
+    const key = planningTapKey(workingDir, boardId);
+    taps.get(key)?.removeAllListeners();
+    taps.delete(key);
+}
+export function resetPlanningTaps() {
+    for (const emitter of taps.values())
+        emitter.removeAllListeners();
+    taps.clear();
+}

package/dist/server/services/sdk/pm-schedule.js

@@ -0,0 +1,165 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolvePmDir } from '../plan/parser.js';
+import { cleanupScheduleSource, isValidTiming, parseUpdatePatch, resolveCreateSource } from '../schedule/schedule-wire.js';
+import { logAppAudit } from './audit.js';
+import { parseBoardRunInput } from './pm.js';
+import { SdkMethodError } from './registry.js';
+function toScheduleSnapshot(record) {
+    const snapshot = {
+        id: record.id,
+        createdAt: record.createdAt,
+        source: { kind: record.source.kind, ...(record.source.originalName ? { originalName: record.source.originalName } : {}) },
+        timing: record.timing,
+        enabled: record.enabled,
+        nextFireAt: record.nextFireAt,
+        history: record.history.map((entry) => ({ ...entry })),
+    };
+    if (record.name !== undefined)
+        snapshot.name = record.name;
+    if (record.input !== undefined)
+        snapshot.input = record.input;
+    if (record.lastFire !== undefined)
+        snapshot.lastFire = { ...record.lastFire };
+    return snapshot;
+}
+let scheduleHost = null;
+export function setSdkPmScheduleHost(host) {
+    scheduleHost = host;
+}
+export function resetSdkPmScheduleHost() {
+    scheduleHost = null;
+}
+function requireScheduleHost(method) {
+    if (!scheduleHost) {
+        throw new SdkMethodError('INTERNAL', `'${method}' host is not wired — the WebSocket handler installs it at startup`);
+    }
+    return scheduleHost;
+}
+function paramsObject(params) {
+    return typeof params === 'object' && params !== null && !Array.isArray(params)
+        ? params
+        : {};
+}
+function parseScheduleIdParams(params, method) {
+    const raw = paramsObject(params);
+    if (typeof raw.scheduleId !== 'string' || raw.scheduleId.trim() === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${method} requires params { scheduleId }`);
+    }
+    return raw.scheduleId;
+}
+function scheduleNotFound(scheduleId) {
+    return new SdkMethodError('BAD_REQUEST', `schedule '${scheduleId}' not found in this Space`);
+}
+function parseCreateParams(params) {
+    const raw = paramsObject(params);
+    const rawSource = paramsObject(raw.source);
+    if (rawSource.kind !== 'template-json' || typeof rawSource.content !== 'string' || rawSource.content === '') {
+        throw new SdkMethodError('BAD_REQUEST', "pm.schedules.create requires params { source: { kind: 'template-json', content }, timing } — board-zip and path-addressed sources are not supported over the SDK");
+    }
+    if (!isValidTiming(raw.timing)) {
+        throw new SdkMethodError('BAD_REQUEST', 'pm.schedules.create requires a valid params.timing');
+    }
+    const parsed = {
+        source: { kind: 'template-json', content: rawSource.content },
+        timing: raw.timing,
+    };
+    if (typeof raw.name === 'string')
+        parsed.name = raw.name;
+    if (raw.enabled !== undefined) {
+        if (typeof raw.enabled !== 'boolean')
+            throw new SdkMethodError('BAD_REQUEST', 'pm.schedules.create enabled must be a boolean when present');
+        parsed.enabled = raw.enabled;
+    }
+    if (raw.input !== undefined)
+        parsed.input = parseBoardRunInput(raw.input, 'pm.schedules.create');
+    return parsed;
+}
+function parseUpdateParams(params) {
+    const raw = paramsObject(params);
+    const scheduleId = parseScheduleIdParams(params, 'pm.schedules.update');
+    const rawPatch = raw.patch;
+    if (rawPatch !== undefined && (typeof rawPatch !== 'object' || rawPatch === null || Array.isArray(rawPatch))) {
+        throw new SdkMethodError('BAD_REQUEST', 'pm.schedules.update patch must be an object when present');
+    }
+    const safePatch = parseUpdatePatch(rawPatch);
+    if (!safePatch)
+        throw new SdkMethodError('BAD_REQUEST', 'pm.schedules.update: invalid patch.timing');
+    if (safePatch.input !== undefined && safePatch.input !== null) {
+        safePatch.input = parseBoardRunInput(safePatch.input, 'pm.schedules.update');
+    }
+    return { scheduleId, patch: safePatch };
+}
+export function pmSchedulesListHandler(args) {
+    const host = requireScheduleHost(args.method);
+    const store = host.getStore(args.workingDir);
+    if (!store)
+        return { schedules: [] };
+    return { schedules: store.list().map(toScheduleSnapshot) };
+}
+export function pmSchedulesCreateHandler(args) {
+    const host = requireScheduleHost(args.method);
+    const { name, source, timing, input, enabled } = parseCreateParams(args.params);
+    const pmDir = resolvePmDir(args.workingDir);
+    if (!pmDir) {
+        throw new SdkMethodError('BAD_REQUEST', 'pm.schedules.create: no PM directory in this Space yet — create a board first');
+    }
+    let resolved;
+    try {
+        resolved = resolveCreateSource(source, args.workingDir, pmDir);
+    }
+    catch (error) {
+        throw new SdkMethodError('BAD_REQUEST', error instanceof Error ? error.message : String(error));
+    }
+    const store = host.getStore(args.workingDir);
+    if (!store) {
+        throw new SdkMethodError('BAD_REQUEST', 'pm.schedules.create: no PM directory in this Space yet — create a board first');
+    }
+    const record = store.create({ name, source: resolved.source, input, timing, enabled });
+    host.notifyAndBroadcast(args.workingDir);
+    logAppAudit({
+        appId: args.appId,
+        origin: args.origin,
+        method: 'pm.schedules.create.created',
+        decision: 'allow',
+        requestId: args.requestId,
+        spaceKey: args.spaceKey,
+        reason: `schedule ${record.id} created (nextFireAt=${record.nextFireAt ?? 'none'})`,
+    });
+    return toScheduleSnapshot(record);
+}
+export function pmSchedulesUpdateHandler(args) {
+    const host = requireScheduleHost(args.method);
+    const { scheduleId, patch } = parseUpdateParams(args.params);
+    const store = host.getStore(args.workingDir);
+    if (!store)
+        throw scheduleNotFound(scheduleId);
+    const record = store.update(scheduleId, patch);
+    if (!record)
+        throw scheduleNotFound(scheduleId);
+    host.notifyAndBroadcast(args.workingDir);
+    return toScheduleSnapshot(record);
+}
+export function pmSchedulesDeleteHandler(args) {
+    const host = requireScheduleHost(args.method);
+    const scheduleId = parseScheduleIdParams(args.params, args.method);
+    const pmDir = resolvePmDir(args.workingDir);
+    const store = host.getStore(args.workingDir);
+    if (!store || !pmDir)
+        throw scheduleNotFound(scheduleId);
+    const record = store.get(scheduleId);
+    if (!record || !store.delete(scheduleId))
+        throw scheduleNotFound(scheduleId);
+    cleanupScheduleSource(pmDir, record);
+    host.notifyAndBroadcast(args.workingDir);
+    logAppAudit({
+        appId: args.appId,
+        origin: args.origin,
+        method: 'pm.schedules.delete.deleted',
+        decision: 'allow',
+        requestId: args.requestId,
+        spaceKey: args.spaceKey,
+        reason: `schedule ${scheduleId} deleted`,
+    });
+    return null;
+}