@minionry/minion 0.7.36

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

@@ -0,0 +1,399 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createHash, randomUUID } from 'node:crypto';
+import { manifestHash, validateManifest } from '@minionry/app-manifest';
+import { buildClonedApp } from '../apps/build.js';
+import { BUILD_COMMANDS, ensureBuildGreenlight, isBuildApproved, resolveGreenlightDecision } from '../apps/greenlight.js';
+import { cloneAppAtPinnedSha } from '../apps/install.js';
+import { errorText } from '../apps/layout.js';
+import { applyAppUpdate, getServeRoster, getStoredBindingManifest, isAppServing, markAppErrorState, markAppPipelineState, persistServedCommitSha, prepareAppUpdate, resumeSpaceServes, settleAppSteadyState, startAppServe, stopAppServe, uninstallLocalApp, } from '../apps/serve.js';
+import { addSpaceApp, initSpaceHiddenBuiltins, readSpaceAppConfig, readSpaceApps, removeSpaceApp, SpaceAppConfigError, SpaceRosterFullError, sanitizeSpaceEntryMeta, setSpaceBuiltinHidden, } from '../apps/space-apps.js';
+import { getClientId } from '../client-id.js';
+import { logAppAudit } from '../sdk/audit.js';
+import { removeAppEndpoints } from '../sdk/endpoints.js';
+import { revokeAppGrantsInSpace } from '../sdk/revoke.js';
+import { isValidAppId } from '../sdk/sandbox.js';
+import { makeSpaceKey } from '../settings.js';
+const COMMIT_SHA_PATTERN = /^[0-9a-f]{40}$/i;
+const sha256Hex = (input) => createHash('sha256').update(input, 'utf8').digest('hex');
+function sendAppError(ctx, ws, operation, code, message, appId) {
+    const data = { operation, code, message, ...(appId ? { appId } : {}) };
+    ctx.send(ws, { type: 'appError', data });
+}
+function sendRoster(ctx, ws, workingDir) {
+    ctx.send(ws, { type: 'appServeStatus', data: getServeRoster(workingDir) });
+}
+function broadcastRoster(ctx, workingDir) {
+    ctx.broadcastToAll({ type: 'appServeStatus', data: getServeRoster(workingDir) });
+}
+function spaceRosterPayload(config) {
+    return { apps: config.apps, hiddenBuiltins: config.hiddenBuiltins };
+}
+function sendSpaceRoster(ctx, ws, workingDir) {
+    ctx.send(ws, { type: 'appSpaceList', data: spaceRosterPayload(readSpaceAppConfig(workingDir)) });
+}
+function broadcastSpaceRoster(ctx, workingDir, config = readSpaceAppConfig(workingDir)) {
+    ctx.broadcastToAll({ type: 'appSpaceList', data: spaceRosterPayload(config) });
+}
+function failPipeline(ctx, ws, operation, workingDir, appId, code, message) {
+    markAppErrorState(workingDir, appId, message);
+    broadcastRoster(ctx, workingDir);
+    sendAppError(ctx, ws, operation, code, message, appId);
+}
+function asRecord(data) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data))
+        return null;
+    return data;
+}
+function stringField(raw, field) {
+    const value = raw[field];
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+function requireAppId(ctx, ws, operation, data) {
+    const raw = asRecord(data);
+    const appId = raw ? stringField(raw, 'appId') : null;
+    if (!appId) {
+        sendAppError(ctx, ws, operation, 'BAD_REQUEST', `${operation} requires a non-empty string appId`);
+        return null;
+    }
+    return appId;
+}
+function buildLogBroadcaster(ctx, appId) {
+    return ({ stream, chunk }) => {
+        const data = { appId, stream, chunk };
+        ctx.broadcastToAll({ type: 'appBuildLog', data });
+    };
+}
+async function passBuildGreenlight(ctx, ws, operation, workingDir, appId, terms, settle) {
+    if (!isBuildApproved(workingDir, appId, terms)) {
+        markAppPipelineState(workingDir, appId, 'awaiting-greenlight');
+        broadcastRoster(ctx, workingDir);
+    }
+    const consent = await ensureBuildGreenlight(workingDir, appId, terms, {
+        broadcast: (payload) => ctx.broadcastToAll({ type: 'appGreenlightRequest', data: payload }),
+    });
+    if (consent.ok)
+        return true;
+    if (settle === 'error') {
+        failPipeline(ctx, ws, operation, workingDir, appId, consent.code, consent.error);
+    }
+    else {
+        settleAppSteadyState(workingDir, appId);
+        broadcastRoster(ctx, workingDir);
+        sendAppError(ctx, ws, operation, consent.code, consent.error, appId);
+    }
+    return false;
+}
+async function handleAppInstallLocal(ctx, ws, data, workingDir) {
+    const appId = requireAppId(ctx, ws, 'appInstallLocal', data);
+    if (!appId)
+        return;
+    const raw = asRecord(data);
+    const repoUrl = stringField(raw, 'repoUrl');
+    if (!repoUrl) {
+        sendAppError(ctx, ws, 'appInstallLocal', 'BAD_REQUEST', 'appInstallLocal requires a non-empty string repoUrl', appId);
+        return;
+    }
+    const commitSha = stringField(raw, 'commitSha');
+    if (!commitSha || !COMMIT_SHA_PATTERN.test(commitSha)) {
+        sendAppError(ctx, ws, 'appInstallLocal', 'BAD_REQUEST', 'appInstallLocal requires commitSha to be a full 40-hex commit SHA (never a branch or tag)', appId);
+        return;
+    }
+    const manifestResult = validateManifest(raw.pinnedManifest);
+    if (!manifestResult.ok) {
+        sendAppError(ctx, ws, 'appInstallLocal', 'BAD_REQUEST', `appInstallLocal pinnedManifest is not a valid IS-016 pinned manifest: ${manifestResult.errors.join('; ')}`, appId);
+        return;
+    }
+    const bindingManifest = {
+        hash: await manifestHash(raw.pinnedManifest, sha256Hex),
+        scopes: manifestResult.manifest.scopes,
+        optionalScopes: manifestResult.manifest.optionalScopes ?? [],
+    };
+    try {
+        const named = readSpaceApps(workingDir).some((entry) => entry.appId === appId && entry.name !== undefined);
+        const joined = addSpaceApp(workingDir, appId, named ? { kind: 'local' } : { kind: 'local', name: manifestResult.manifest.name });
+        if (joined.changed)
+            broadcastSpaceRoster(ctx, workingDir, joined);
+    }
+    catch (err) {
+        console.error(`[apps] failed to add '${appId}' to this Space's app roster: ${errorText(err)}`);
+    }
+    markAppPipelineState(workingDir, appId, 'installing');
+    broadcastRoster(ctx, workingDir);
+    const result = await cloneAppAtPinnedSha({ workingDir, appId, repoUrl, commitSha });
+    if (!result.ok) {
+        failPipeline(ctx, ws, 'appInstallLocal', workingDir, appId, result.code, result.error);
+        return;
+    }
+    const proceed = await passBuildGreenlight(ctx, ws, 'appInstallLocal', workingDir, appId, { repoUrl, commitSha: result.commitSha, commands: BUILD_COMMANDS }, 'error');
+    if (!proceed)
+        return;
+    markAppPipelineState(workingDir, appId, 'building');
+    broadcastRoster(ctx, workingDir);
+    const build = await buildClonedApp({
+        workingDir,
+        appId,
+        repoUrl,
+        commitSha: result.commitSha,
+        onLog: buildLogBroadcaster(ctx, appId),
+    });
+    if (!build.ok) {
+        failPipeline(ctx, ws, 'appInstallLocal', workingDir, appId, build.code, build.error);
+        return;
+    }
+    const serve = await startAppServe({ workingDir, appId, commitSha: result.commitSha, repoUrl, manifest: bindingManifest });
+    if (!serve.ok) {
+        failPipeline(ctx, ws, 'appInstallLocal', workingDir, appId, serve.code, serve.error);
+        return;
+    }
+    broadcastRoster(ctx, workingDir);
+}
+async function handleAppStop(ctx, ws, data, workingDir) {
+    const appId = requireAppId(ctx, ws, 'appStop', data);
+    if (!appId)
+        return;
+    const result = await stopAppServe(workingDir, appId);
+    if (!result.ok) {
+        sendAppError(ctx, ws, 'appStop', result.code, result.error, appId);
+        return;
+    }
+    broadcastRoster(ctx, workingDir);
+}
+async function handleAppUpdate(ctx, ws, data, workingDir) {
+    const appId = requireAppId(ctx, ws, 'appUpdate', data);
+    if (!appId)
+        return;
+    const prep = await prepareAppUpdate(workingDir, appId);
+    if (!prep.ok) {
+        sendAppError(ctx, ws, 'appUpdate', prep.code, prep.error, appId);
+        return;
+    }
+    if (prep.remoteSha === prep.currentSha) {
+        sendRoster(ctx, ws, workingDir);
+        return;
+    }
+    const proceed = await passBuildGreenlight(ctx, ws, 'appUpdate', workingDir, appId, { repoUrl: prep.repoUrl, commitSha: prep.remoteSha, commands: BUILD_COMMANDS }, 'steady');
+    if (!proceed)
+        return;
+    markAppPipelineState(workingDir, appId, 'building');
+    broadcastRoster(ctx, workingDir);
+    const checkoutFailure = await applyAppUpdate(workingDir, appId, prep.remoteSha);
+    if (checkoutFailure) {
+        failPipeline(ctx, ws, 'appUpdate', workingDir, appId, 'INTERNAL', checkoutFailure);
+        return;
+    }
+    const build = await buildClonedApp({
+        workingDir,
+        appId,
+        repoUrl: prep.repoUrl,
+        commitSha: prep.remoteSha,
+        onLog: buildLogBroadcaster(ctx, appId),
+    });
+    if (!build.ok) {
+        failPipeline(ctx, ws, 'appUpdate', workingDir, appId, build.code, build.error);
+        return;
+    }
+    const manifest = getStoredBindingManifest(workingDir, appId);
+    if (isAppServing(workingDir, appId) && manifest) {
+        const serve = await startAppServe({ workingDir, appId, commitSha: prep.remoteSha, repoUrl: prep.repoUrl, manifest });
+        if (!serve.ok) {
+            failPipeline(ctx, ws, 'appUpdate', workingDir, appId, serve.code, serve.error);
+            return;
+        }
+    }
+    else {
+        persistServedCommitSha(workingDir, appId, prep.remoteSha);
+        settleAppSteadyState(workingDir, appId);
+    }
+    broadcastRoster(ctx, workingDir);
+}
+function handleAppGreenlightDecision(ctx, ws, data, workingDir) {
+    const raw = asRecord(data);
+    const greenlightId = raw ? stringField(raw, 'greenlightId') : null;
+    const appId = raw ? stringField(raw, 'appId') : null;
+    if (!raw || !greenlightId || !appId || typeof raw.approved !== 'boolean') {
+        sendAppError(ctx, ws, 'appGreenlightDecision', 'BAD_REQUEST', 'appGreenlightDecision requires greenlightId, appId, and a boolean approved');
+        return;
+    }
+    if (!resolveGreenlightDecision(greenlightId, appId, raw.approved)) {
+        sendAppError(ctx, ws, 'appGreenlightDecision', 'BAD_REQUEST', `no pending greenlight '${greenlightId}' for ${appId} — the card may already be answered, timed out, or superseded`, appId);
+        return;
+    }
+    sendRoster(ctx, ws, workingDir);
+}
+function requireRosterAppId(ctx, ws, operation, data) {
+    const appId = requireAppId(ctx, ws, operation, data);
+    if (!appId)
+        return null;
+    if (!isValidAppId(appId)) {
+        sendAppError(ctx, ws, operation, 'BAD_REQUEST', `${operation} requires appId to match the D5 grammar (lowercase [a-z0-9-])`);
+        return null;
+    }
+    return appId;
+}
+function handleAppSpaceAdd(ctx, ws, data, workingDir) {
+    const appId = requireRosterAppId(ctx, ws, 'appSpaceAdd', data);
+    if (!appId)
+        return;
+    const raw = asRecord(data);
+    let config;
+    try {
+        config = addSpaceApp(workingDir, appId, sanitizeSpaceEntryMeta(raw));
+    }
+    catch (err) {
+        if (err instanceof SpaceRosterFullError) {
+            sendAppError(ctx, ws, 'appSpaceAdd', 'BAD_REQUEST', err.message, appId);
+            return;
+        }
+        sendAppError(ctx, ws, 'appSpaceAdd', 'INTERNAL', `failed to add '${appId}' to this Space's app roster: ${errorText(err)}`, appId);
+        return;
+    }
+    broadcastSpaceRoster(ctx, workingDir, config);
+}
+function revokeForPurge(ctx, ws, appId, workingDir) {
+    const spaceKey = makeSpaceKey(getClientId(), workingDir);
+    try {
+        revokeAppGrantsInSpace(appId, spaceKey, (frame) => {
+            const out = { type: frame.type, data: frame.data };
+            if (frame.broadcast)
+                ctx.broadcastToAll(out);
+            else
+                ctx.send(ws, out);
+        });
+        logAppAudit({
+            appId,
+            origin: readSpaceApps(workingDir).find((entry) => entry.appId === appId)?.entry ?? '',
+            method: 'grants.revoke',
+            decision: 'allow',
+            requestId: randomUUID(),
+            spaceKey,
+            reason: 'Space uninstall (appSpaceRemove purge)',
+        });
+    }
+    catch (err) {
+        sendAppError(ctx, ws, 'appSpaceRemove', 'INTERNAL', `failed to revoke '${appId}'s access on this Space: ${errorText(err)}`, appId);
+    }
+}
+function removeEndpointsForSpaceRemoval(ctx, ws, appId, workingDir) {
+    try {
+        removeAppEndpoints(appId, makeSpaceKey(getClientId(), workingDir), 'removed from Space');
+    }
+    catch (err) {
+        sendAppError(ctx, ws, 'appSpaceRemove', 'INTERNAL', `failed to remove the endpoints '${appId}' registered on this Space: ${errorText(err)}`, appId);
+    }
+}
+async function handleAppSpaceRemove(ctx, ws, data, workingDir) {
+    const appId = requireRosterAppId(ctx, ws, 'appSpaceRemove', data);
+    if (!appId)
+        return;
+    const purge = asRecord(data).purge === true;
+    if (purge)
+        revokeForPurge(ctx, ws, appId, workingDir);
+    removeEndpointsForSpaceRemoval(ctx, ws, appId, workingDir);
+    const wasServing = isAppServing(workingDir, appId);
+    const teardown = purge
+        ? await uninstallLocalApp(workingDir, appId)
+        : wasServing
+            ? await stopAppServe(workingDir, appId)
+            : null;
+    let removed = null;
+    try {
+        removed = removeSpaceApp(workingDir, appId);
+    }
+    catch (err) {
+        sendAppError(ctx, ws, 'appSpaceRemove', 'INTERNAL', `failed to remove '${appId}' from this Space's app roster: ${errorText(err)}`, appId);
+    }
+    if (removed)
+        broadcastSpaceRoster(ctx, workingDir, removed);
+    if (wasServing || purge)
+        broadcastRoster(ctx, workingDir);
+    if (teardown && !teardown.ok) {
+        const step = purge ? 'delete its local files' : 'stop its local serve';
+        sendAppError(ctx, ws, 'appSpaceRemove', teardown.code, `removed '${appId}' from this Space, but failed to ${step}: ${teardown.error}`, appId);
+    }
+}
+function stringList(value) {
+    return Array.isArray(value) && value.every((id) => typeof id === 'string') ? value : null;
+}
+const SPACE_CONFIG_COMMANDS = new Map([
+    [
+        'setBuiltinHidden',
+        (ctx, ws, raw, workingDir) => {
+            const appId = requireRosterAppId(ctx, ws, 'appSpaceConfigure', raw);
+            if (!appId)
+                return null;
+            const base = raw.base === undefined ? [] : stringList(raw.base);
+            if (typeof raw.hidden !== 'boolean' || base === null) {
+                sendAppError(ctx, ws, 'appSpaceConfigure', 'BAD_REQUEST', 'setBuiltinHidden requires a boolean hidden and, when given, base as a list of app ids', appId);
+                return null;
+            }
+            return setSpaceBuiltinHidden(workingDir, appId, raw.hidden, base);
+        },
+    ],
+    [
+        'initHiddenBuiltins',
+        (ctx, ws, raw, workingDir) => {
+            const ids = stringList(raw.hiddenBuiltins);
+            if (ids === null) {
+                sendAppError(ctx, ws, 'appSpaceConfigure', 'BAD_REQUEST', 'initHiddenBuiltins requires hiddenBuiltins as a list of app ids');
+                return null;
+            }
+            return initSpaceHiddenBuiltins(workingDir, ids);
+        },
+    ],
+]);
+function handleAppSpaceConfigure(ctx, ws, data, workingDir) {
+    const raw = asRecord(data);
+    const op = raw ? stringField(raw, 'op') : null;
+    const command = op !== null ? SPACE_CONFIG_COMMANDS.get(op) : undefined;
+    if (!raw || !command) {
+        sendAppError(ctx, ws, 'appSpaceConfigure', 'BAD_REQUEST', `appSpaceConfigure requires a known op (${[...SPACE_CONFIG_COMMANDS.keys()].join(', ')})`);
+        return;
+    }
+    let config;
+    try {
+        config = command(ctx, ws, raw, workingDir);
+    }
+    catch (err) {
+        if (err instanceof SpaceAppConfigError) {
+            sendAppError(ctx, ws, 'appSpaceConfigure', 'BAD_REQUEST', err.message);
+            return;
+        }
+        sendAppError(ctx, ws, 'appSpaceConfigure', 'INTERNAL', `failed to update this Space's app configuration: ${errorText(err)}`);
+        return;
+    }
+    if (config)
+        broadcastSpaceRoster(ctx, workingDir, config);
+}
+export async function handleAppsMessage(ctx, ws, msg, workingDir) {
+    if (await resumeSpaceServes(workingDir)) {
+        broadcastRoster(ctx, workingDir);
+    }
+    switch (msg.type) {
+        case 'appServeStatus': {
+            sendRoster(ctx, ws, workingDir);
+            return;
+        }
+        case 'appInstallLocal':
+            return handleAppInstallLocal(ctx, ws, msg.data, workingDir);
+        case 'appStop':
+            return handleAppStop(ctx, ws, msg.data, workingDir);
+        case 'appUpdate':
+            return handleAppUpdate(ctx, ws, msg.data, workingDir);
+        case 'appGreenlightDecision':
+            handleAppGreenlightDecision(ctx, ws, msg.data, workingDir);
+            return;
+        case 'appSpaceList': {
+            sendSpaceRoster(ctx, ws, workingDir);
+            return;
+        }
+        case 'appSpaceAdd':
+            handleAppSpaceAdd(ctx, ws, msg.data, workingDir);
+            return;
+        case 'appSpaceRemove':
+            return handleAppSpaceRemove(ctx, ws, msg.data, workingDir);
+        case 'appSpaceConfigure':
+            handleAppSpaceConfigure(ctx, ws, msg.data, workingDir);
+            return;
+    }
+}

package/dist/server/services/websocket/ask-user-question-bridge.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID, timingSafeEqual } from 'node:crypto';
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+const pending = new Map();
+const bouncerSharedSecret = randomUUID();
+export function getBouncerSecret() {
+    return bouncerSharedSecret;
+}
+export function isValidBouncerSecret(secret) {
+    if (!secret)
+        return false;
+    const claimed = Buffer.from(secret);
+    const actual = Buffer.from(bouncerSharedSecret);
+    if (claimed.length !== actual.length)
+        return false;
+    return timingSafeEqual(claimed, actual);
+}
+const CAPABILITY_TOKEN_TTL_MS = 12 * 60 * 60 * 1000;
+const capabilities = new Map();
+export function mintMcpCapabilityToken(capability, ttlMs = CAPABILITY_TOKEN_TTL_MS) {
+    const token = randomUUID();
+    const timer = setTimeout(() => {
+        capabilities.delete(token);
+    }, ttlMs);
+    timer.unref();
+    capabilities.set(token, { capability: Object.freeze({ ...capability }), timer });
+    return { token, revoke: () => revokeMcpCapabilityToken(token) };
+}
+export function resolveMcpCapability(token) {
+    if (!token)
+        return null;
+    return capabilities.get(token)?.capability ?? null;
+}
+export function revokeMcpCapabilityToken(token) {
+    const entry = capabilities.get(token);
+    if (!entry)
+        return;
+    clearTimeout(entry.timer);
+    capabilities.delete(token);
+}
+export function mcpCapabilityTokenCount() {
+    return capabilities.size;
+}
+export function registerPendingQuestion(opts) {
+    const { toolUseId, tabId, questions = [], timeoutMs = DEFAULT_TIMEOUT_MS, computeTimeoutAnswers } = opts;
+    const existing = pending.get(toolUseId);
+    if (existing) {
+        clearTimeout(existing.timer);
+        existing.reject('cancelled');
+        pending.delete(toolUseId);
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            const entry = pending.get(toolUseId);
+            if (!entry)
+                return;
+            pending.delete(toolUseId);
+            if (computeTimeoutAnswers) {
+                entry.resolve({ answers: computeTimeoutAnswers(), timedOut: true });
+            }
+            else {
+                entry.reject('timeout');
+            }
+        }, timeoutMs);
+        pending.set(toolUseId, {
+            toolUseId,
+            tabId,
+            questions,
+            resolve,
+            reject: (reason) => reject(new Error(reason)),
+            timer,
+            createdAt: Date.now(),
+        });
+    });
+}
+export function resolvePendingQuestion(toolUseId, answers) {
+    const entry = pending.get(toolUseId);
+    if (!entry)
+        return false;
+    pending.delete(toolUseId);
+    clearTimeout(entry.timer);
+    entry.resolve({ answers, timedOut: false });
+    return true;
+}
+export function cancelPendingQuestionsForTab(tabId, reason = 'cancelled') {
+    const cancelled = [];
+    for (const [id, entry] of pending) {
+        if (entry.tabId !== tabId)
+            continue;
+        pending.delete(id);
+        clearTimeout(entry.timer);
+        entry.reject(reason);
+        cancelled.push(id);
+    }
+    return cancelled;
+}
+export function getPendingQuestionTab(toolUseId) {
+    return pending.get(toolUseId)?.tabId;
+}
+export function getPendingQuestionsForTab(tabId) {
+    const out = [];
+    for (const entry of pending.values()) {
+        if (entry.tabId === tabId) {
+            out.push({ toolUseId: entry.toolUseId, questions: entry.questions });
+        }
+    }
+    return out;
+}
+export function pendingQuestionCount() {
+    return pending.size;
+}