@minionry/minion 0.7.36

package/dist/server/services/websocket/sdk-handlers.js

@@ -0,0 +1,242 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { join } from 'node:path';
+import { parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
+import { injectGatherIssue, writeRunInputFile } from '../schedule/run-bootstrap.js';
+import { resolveSdkConsent } from '../sdk/connect.js';
+import { runSdkPipeline } from '../sdk/pipeline.js';
+import { setSdkPmHost } from '../sdk/pm.js';
+import { handleChatToBoard } from './plan-board-handlers.js';
+import { executorCache, getWatcher } from './plan-helpers.js';
+import { installSdkPmExecutionHost } from './sdk-pm-execution-host.js';
+import { installSdkPmScheduleHost } from './sdk-pm-schedule-host.js';
+import { installSdkQualityScheduleHost } from './sdk-quality-schedule-host.js';
+export { SDK_READ_METHODS, SDK_WRITE_CAPABILITY } from '../sdk/registry.js';
+function interpretChatToBoardFrame(raw) {
+    let frame;
+    try {
+        frame = JSON.parse(String(raw));
+    }
+    catch {
+        return null;
+    }
+    if (frame.type === 'chatToBoardCreated') {
+        const data = (frame.data ?? {});
+        return typeof data.boardId === 'string' && data.boardId !== ''
+            ? { kind: 'created', boardId: data.boardId }
+            : { kind: 'failed', message: 'chatToBoardCreated carried no boardId' };
+    }
+    if (frame.type === 'planError') {
+        const data = (frame.data ?? {});
+        const message = typeof data.error === 'string' && data.error !== '' ? data.error : 'board creation failed';
+        return { kind: 'failed', message };
+    }
+    return null;
+}
+export function renderRunVariablesBlock(variables) {
+    const lines = Object.entries(variables).map(([name, value]) => `- ${name}: ${value}`);
+    return ['## Run Variables', '', ...lines].join('\n');
+}
+export function applyRunInputData(workingDir, boardId, data) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    try {
+        writeRunInputFile(join(pmDir, 'boards', boardId), { boardId, data });
+    }
+    catch (error) {
+        console.error(`[SdkHandlers] failed to write run-input.json for board ${boardId}:`, error);
+    }
+}
+export function applyGatherPrompt(workingDir, boardId, gatherPrompt, hasRunInput) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    try {
+        injectGatherIssue(join(pmDir, 'boards', boardId), gatherPrompt, { hasRunInput });
+    }
+    catch (error) {
+        console.error(`[SdkHandlers] failed to inject gather-data issue for board ${boardId}:`, error);
+    }
+}
+function createBoardViaChatToBoard(ctx, request) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let createdBoardId = null;
+        const settle = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            outcome();
+        };
+        const captureWs = {
+            readyState: 1,
+            close: () => { },
+            send: (raw) => {
+                const outcome = interpretChatToBoardFrame(raw);
+                if (!outcome)
+                    return;
+                if (outcome.kind === 'created') {
+                    createdBoardId = outcome.boardId;
+                    if (request.input?.data !== undefined) {
+                        applyRunInputData(request.workingDir, outcome.boardId, request.input.data);
+                    }
+                    settle(() => resolve({ boardId: outcome.boardId }));
+                }
+                else {
+                    settle(() => reject(new Error(outcome.message)));
+                }
+            },
+        };
+        const variables = request.input?.variables;
+        const conversation = variables && Object.keys(variables).length > 0
+            ? `${renderRunVariablesBlock(variables)}\n\n${request.prompt}`
+            : request.prompt;
+        const message = {
+            type: 'chatToBoard',
+            data: { conversation, autoImplement: request.autoImplement },
+        };
+        void handleChatToBoard(ctx, captureWs, message, request.workingDir).then(() => {
+            settle(() => reject(new Error('chatToBoard ended without announcing a board')));
+            if (createdBoardId && request.input?.gatherPrompt) {
+                applyGatherPrompt(request.workingDir, createdBoardId, request.input.gatherPrompt, request.input.data !== undefined);
+            }
+        }, (error) => settle(() => reject(error instanceof Error ? error : new Error(String(error)))));
+    });
+}
+function installSdkPmHost(ctx) {
+    setSdkPmHost({
+        createBoard: (request) => createBoardViaChatToBoard(ctx, request),
+        subscribeBoardUpdates: (workingDir, listener) => {
+            const watcher = getWatcher(workingDir, ctx);
+            watcher.start();
+            return watcher.onUpdate(listener);
+        },
+        broadcastPlanUpdate: (workingDir) => {
+            getWatcher(workingDir, ctx).start();
+            const fullState = parsePlanDirectory(workingDir);
+            if (fullState)
+                ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+        },
+        stopExecutorIfRunning: (workingDir, boardId) => {
+            const executor = executorCache.get(workingDir);
+            if (!executor)
+                return;
+            const snapshot = executor.getExecutionSnapshot();
+            if (snapshot.boardId === boardId && snapshot.status !== 'idle' && snapshot.status !== 'complete' && snapshot.status !== 'error') {
+                executor.stop();
+            }
+        },
+    });
+}
+function parseSdkEnvelope(data, requireMethod) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        return {
+            ok: false,
+            requestId: '',
+            error: { code: 'BAD_REQUEST', message: 'sdk envelope must be an object carrying appId, origin, and requestId' },
+        };
+    }
+    const raw = data;
+    const requestId = typeof raw.requestId === 'string' ? raw.requestId : '';
+    const invalid = [];
+    if (typeof raw.appId !== 'string' || raw.appId === '')
+        invalid.push('appId');
+    if (typeof raw.origin !== 'string' || raw.origin === '')
+        invalid.push('origin');
+    if (requestId === '')
+        invalid.push('requestId');
+    if (requireMethod && (typeof raw.method !== 'string' || raw.method === ''))
+        invalid.push('method');
+    if (invalid.length > 0) {
+        return {
+            ok: false,
+            requestId,
+            error: { code: 'BAD_REQUEST', message: `sdk envelope has missing or invalid field(s): ${invalid.join(', ')}` },
+        };
+    }
+    return {
+        ok: true,
+        envelope: {
+            appId: raw.appId,
+            origin: raw.origin,
+            requestId,
+            method: typeof raw.method === 'string' && raw.method !== '' ? raw.method : undefined,
+            params: raw.params,
+            manifest: raw.manifest,
+        },
+    };
+}
+function handleSdkConsentDecision(msg, role, viewerId) {
+    const raw = msg.data;
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        console.warn('[SdkHandlers] dropped malformed sdkConsentDecision (not an object)');
+        return;
+    }
+    const data = raw;
+    if (typeof data.consentId !== 'string' ||
+        data.consentId === '' ||
+        typeof data.approved !== 'boolean' ||
+        !Array.isArray(data.granted) ||
+        !data.granted.every((scope) => typeof scope === 'string')) {
+        console.warn('[SdkHandlers] dropped malformed sdkConsentDecision (bad consentId/approved/granted)');
+        return;
+    }
+    const resolution = resolveSdkConsent(data.consentId, { approved: data.approved, granted: data.granted, remember: data.remember === true }, { role, viewerId });
+    if (resolution !== 'resolved') {
+        console.warn(`[SdkHandlers] sdkConsentDecision for '${data.consentId}' dropped: ${resolution}`);
+    }
+}
+export async function handleSdkMessage(ctx, ws, msg, tabId, workingDir, role, viewerId) {
+    installSdkPmHost(ctx);
+    installSdkPmExecutionHost(ctx);
+    installSdkPmScheduleHost(ctx);
+    installSdkQualityScheduleHost();
+    if (msg.type === 'sdkConsentDecision') {
+        handleSdkConsentDecision(msg, role, viewerId);
+        return;
+    }
+    const replyType = msg.type === 'sdkConnect' ? 'sdkConnectResult' : 'sdkResponse';
+    const reply = (payload) => {
+        ctx.send(ws, { type: replyType, tabId, data: payload });
+    };
+    const parsed = parseSdkEnvelope(msg.data, msg.type === 'sdkRequest');
+    if (!parsed.ok) {
+        reply({ requestId: parsed.requestId, ok: false, error: parsed.error });
+        return;
+    }
+    const { envelope } = parsed;
+    const response = await runSdkPipeline({
+        wireType: msg.type,
+        appId: envelope.appId,
+        origin: envelope.origin,
+        requestId: envelope.requestId,
+        method: envelope.method,
+        params: envelope.params,
+        role,
+        viewerId,
+        tabId,
+        workingDir,
+        manifest: envelope.manifest,
+        emit: (event, payload, seq) => {
+            ctx.send(ws, {
+                type: 'sdkEvent',
+                tabId,
+                data: { requestId: envelope.requestId, event, ...(payload !== undefined ? { payload } : {}), seq },
+            });
+        },
+        notify: (frame) => {
+            const out = { type: frame.type, data: frame.data };
+            if (frame.targetViewerId !== undefined) {
+                out._target = frame.targetViewerId;
+            }
+            if (frame.broadcast) {
+                ctx.broadcastToAll(out);
+            }
+            else {
+                ctx.send(ws, out);
+            }
+        },
+    });
+    reply(response);
+}

package/dist/server/services/websocket/sdk-pm-execution-host.js

@@ -0,0 +1,63 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { setSdkPmExecutionHost } from '../sdk/pm-execute.js';
+import { scopeExecutionDir } from './handler-context.js';
+import { wireExecutorEvents } from './plan-execution-handlers.js';
+import { executorCache, getExecutor } from './plan-helpers.js';
+const currentRunByWorkingDir = new Map();
+function mintRunId() {
+    return `boardrun-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function clearCurrentRun(workingDir, runId) {
+    const current = currentRunByWorkingDir.get(workingDir);
+    if (current?.runId === runId)
+        currentRunByWorkingDir.delete(workingDir);
+}
+export function installSdkPmExecutionHost(ctx) {
+    const host = {
+        attach(workingDir, boardId) {
+            const executor = getExecutor(workingDir);
+            const status = executor.getStatus();
+            const snapshot = executor.getExecutionSnapshot();
+            const busyWithAnotherBoard = (status === 'executing' || status === 'starting') && snapshot.boardId !== null && snapshot.boardId !== boardId;
+            if (busyWithAnotherBoard) {
+                throw new Error(`execution already in progress for board '${snapshot.boardId}' in this Space`);
+            }
+            const current = currentRunByWorkingDir.get(workingDir);
+            const alreadyRunningThisBoard = (status === 'executing' || status === 'starting') && snapshot.boardId === boardId && current?.boardId === boardId;
+            if (alreadyRunningThisBoard) {
+                return { runId: current.runId, on: (event, cb) => executor.on(event, cb), off: (event, cb) => executor.off(event, cb) };
+            }
+            const runId = mintRunId();
+            currentRunByWorkingDir.set(workingDir, { runId, boardId });
+            const executionDir = scopeExecutionDir(ctx, boardId);
+            wireExecutorEvents(executor, ctx, workingDir, boardId, undefined, executionDir);
+            executor.on('complete', () => clearCurrentRun(workingDir, runId));
+            executor.on('error', () => clearCurrentRun(workingDir, runId));
+            ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', boardId } });
+            executor.startBoard(boardId, executionDir).catch((error) => {
+                ctx.broadcastToAll({
+                    type: 'planExecutionError',
+                    data: { error: error instanceof Error ? error.message : String(error), boardId },
+                });
+            });
+            return { runId, on: (event, cb) => executor.on(event, cb), off: (event, cb) => executor.off(event, cb) };
+        },
+        pause(workingDir, boardId) {
+            const executor = executorCache.get(workingDir);
+            if (executor && executor.getExecutionSnapshot().boardId === boardId)
+                executor.pause();
+        },
+        async resume(workingDir, boardId) {
+            const executor = executorCache.get(workingDir);
+            if (executor && executor.getExecutionSnapshot().boardId === boardId)
+                await executor.resume();
+        },
+        stop(workingDir, boardId) {
+            const executor = executorCache.get(workingDir);
+            if (executor && executor.getExecutionSnapshot().boardId === boardId)
+                executor.stop();
+        },
+    };
+    setSdkPmExecutionHost(host);
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { getScheduler } from '../schedule/scheduler.js';
+import { setSdkPmScheduleHost } from '../sdk/pm-schedule.js';
+export function installSdkPmScheduleHost(ctx) {
+    const host = {
+        getStore(workingDir) {
+            const engine = getScheduler(workingDir, ctx);
+            engine.start();
+            return engine.getStore();
+        },
+        notifyAndBroadcast(workingDir) {
+            const engine = getScheduler(workingDir, ctx);
+            engine.tick();
+            const store = engine.getStore();
+            if (store)
+                ctx.broadcastToAll({ type: 'planSchedulesChanged', data: { schedules: store.list() } });
+        },
+    };
+    setSdkPmScheduleHost(host);
+}

package/dist/server/services/websocket/sdk-quality-schedule-host.js

@@ -0,0 +1,34 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { getClientId } from '../client-id.js';
+import { getQualityScheduler, setQualitySchedulerDefaults } from '../schedule/quality-scheduler.js';
+import { notifyQualityChanged } from '../sdk/quality-change-notify.js';
+import { setSdkQualityScheduleHost, toQualityScheduleSnapshot } from '../sdk/quality-schedule.js';
+import { makeSpaceKey } from '../settings.js';
+export function announceQualitySchedules(workingDir, schedules) {
+    notifyQualityChanged(makeSpaceKey(getClientId(), workingDir), {
+        kind: 'schedules',
+        schedules: schedules.map(toQualityScheduleSnapshot),
+    });
+}
+export function installSdkQualityScheduleHost() {
+    setQualitySchedulerDefaults({ onChanged: announceQualitySchedules });
+    const host = {
+        getStore(workingDir) {
+            const engine = getQualityScheduler(workingDir);
+            engine.start();
+            const store = engine.getStore();
+            if (!store)
+                throw new Error('quality scheduler failed to start for this Space');
+            return store;
+        },
+        notify(workingDir) {
+            const engine = getQualityScheduler(workingDir);
+            engine.tick();
+            const store = engine.getStore();
+            if (store)
+                announceQualitySchedules(workingDir, store.list());
+        },
+    };
+    setSdkQualityScheduleHost(host);
+}

package/dist/server/services/websocket/sdk-terminal-host.js

@@ -0,0 +1,140 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomBytes } from 'node:crypto';
+import { platform } from 'node:os';
+import { SDK_TERMINAL_ID_PREFIX, setSdkTerminalHost, } from '../sdk/terminal.js';
+import { getPTYManager, reloadPty } from '../terminal/pty-manager.js';
+import { resolveEffectiveCwd } from './terminal-handlers.js';
+export { SDK_TERMINAL_ID_PREFIX } from '../sdk/terminal.js';
+const sessionListeners = new Set();
+function notifySessionChange(change) {
+    for (const listener of [...sessionListeners]) {
+        try {
+            listener(change);
+        }
+        catch {
+        }
+    }
+}
+export function notifySdkTerminalSessionOpened(terminalId) {
+    const session = summarizeSession(terminalId);
+    if (session)
+        notifySessionChange({ kind: 'opened', session });
+}
+export function resetSdkTerminalNotifications() {
+    sessionListeners.clear();
+    if (managerExitCleanup) {
+        managerExitCleanup();
+        managerExitCleanup = null;
+    }
+}
+function summarizeSession(id) {
+    const session = getPTYManager().getSession(id);
+    if (!session)
+        return null;
+    return {
+        id,
+        shell: session.shell,
+        cwd: session.cwd,
+        cols: session.cols,
+        rows: session.rows,
+        createdAt: new Date(session.createdAt).toISOString(),
+        lastActivityAt: new Date(session.lastActivityAt).toISOString(),
+        ...(session.ownerLabel !== undefined ? { ownerLabel: session.ownerLabel } : {}),
+    };
+}
+let managerExitCleanup = null;
+function wireManagerExitListener() {
+    if (managerExitCleanup)
+        return;
+    const ptyManager = getPTYManager();
+    const onExit = (terminalId) => {
+        notifySessionChange({ kind: 'closed', id: terminalId });
+    };
+    ptyManager.on('exit', onExit);
+    managerExitCleanup = () => ptyManager.off('exit', onExit);
+}
+export function installSdkTerminalHost(ctx) {
+    wireManagerExitListener();
+    const host = {
+        async ensurePtyAvailable() {
+            const ptyManager = getPTYManager();
+            if (!ptyManager.isPtyAvailable()) {
+                await reloadPty();
+            }
+            return ptyManager.isPtyAvailable();
+        },
+        isPtyAvailable: () => getPTYManager().isPtyAvailable(),
+        installInstructions: () => getPTYManager().getPtyInstallInstructions(),
+        listSessions() {
+            return getPTYManager()
+                .getActiveTerminals()
+                .map((id) => summarizeSession(id))
+                .filter((session) => session !== null);
+        },
+        async open(args) {
+            const ptyManager = getPTYManager();
+            const id = `${SDK_TERMINAL_ID_PREFIX}${randomBytes(12).toString('hex')}`;
+            const cwd = resolveEffectiveCwd(args.cwd, args.workingDir);
+            const created = await ptyManager.create(id, cwd, args.cols, args.rows, undefined, args.appId);
+            ctx.broadcastToAll({
+                type: 'terminalCreated',
+                data: { terminalId: id, shell: created.shell, cwd: created.cwd, ownerLabel: args.appId },
+            });
+            notifySdkTerminalSessionOpened(id);
+            return { id, shell: created.shell, cwd: created.cwd, cols: args.cols, rows: args.rows, platform: platform() };
+        },
+        exists: (id) => getPTYManager().exists(id),
+        write: (id, data) => getPTYManager().write(id, data),
+        resize: (id, cols, rows) => getPTYManager().resize(id, cols, rows),
+        close(id) {
+            const ptyManager = getPTYManager();
+            const info = ptyManager.getSessionInfo(id);
+            if (!info)
+                return false;
+            ptyManager.close(id);
+            ctx.broadcastToAll({
+                type: 'terminalClosed',
+                data: {
+                    terminalId: id,
+                    ...(info.ownerLabel !== undefined ? { ownerLabel: info.ownerLabel } : {}),
+                },
+            });
+            return true;
+        },
+        getScrollback: (id) => getPTYManager().getScrollback(id),
+        attach(id, callbacks) {
+            const ptyManager = getPTYManager();
+            const onOutput = (tid, data) => {
+                if (tid === id)
+                    callbacks.onOutput(data);
+            };
+            const onExit = (tid, exitCode) => {
+                if (tid === id)
+                    callbacks.onExit(exitCode);
+            };
+            const onError = (tid, error) => {
+                if (tid === id)
+                    callbacks.onError(error);
+            };
+            ptyManager.on('output', onOutput);
+            ptyManager.on('exit', onExit);
+            ptyManager.on('error', onError);
+            let detached = false;
+            return () => {
+                if (detached)
+                    return;
+                detached = true;
+                ptyManager.off('output', onOutput);
+                ptyManager.off('exit', onExit);
+                ptyManager.off('error', onError);
+            };
+        },
+        subscribeSessions(cb) {
+            sessionListeners.add(cb);
+            return () => sessionListeners.delete(cb);
+        },
+    };
+    setSdkTerminalHost(host);
+    return host;
+}