@minionry/minion 0.7.36

package/dist/server/routes/internal.js

@@ -0,0 +1,900 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { getConnInfo } from '@hono/node-server/conninfo';
+import { Hono } from 'hono';
+import { invokeExposedAppTool, listExposedAppTools, } from '../mcp/app-tools-bridge.js';
+import { parseQualityCheckPaths, runQualityCheck } from '../mcp/quality-bridge.js';
+import { getBrowserDriverState, INPUT_MUTATING_BROWSER_TOOLS, } from '../services/browser/driver-state.js';
+import { deriveSpaceBrowserAgentId } from '../services/instances.js';
+import { getBouncerSecret, isValidBouncerSecret, registerPendingQuestion, resolveMcpCapability, } from '../services/websocket/ask-user-question-bridge.js';
+import { broadcastAgentTabState } from '../services/websocket/browser-agent-runtime.js';
+import { selectRecommendedAnswers } from '../services/websocket/recommended-answers.js';
+import { broadcastTabEvent } from '../services/websocket/tab-broadcast.js';
+export { getBouncerSecret };
+function parseQuestions(value) {
+    if (!Array.isArray(value))
+        return null;
+    const out = [];
+    for (const raw of value) {
+        if (!raw || typeof raw !== 'object')
+            return null;
+        const r = raw;
+        if (typeof r.question !== 'string' || typeof r.header !== 'string')
+            return null;
+        if (!Array.isArray(r.options))
+            return null;
+        const options = r.options.map((o) => {
+            if (!o || typeof o !== 'object')
+                return null;
+            const oo = o;
+            if (typeof oo.label !== 'string')
+                return null;
+            return {
+                label: oo.label,
+                description: typeof oo.description === 'string' ? oo.description : '',
+                preview: typeof oo.preview === 'string' ? oo.preview : undefined,
+            };
+        });
+        if (options.some((o) => o === null))
+            return null;
+        out.push({
+            question: r.question,
+            header: r.header,
+            options: options,
+            multiSelect: r.multiSelect === true,
+        });
+    }
+    return out;
+}
+function parseAskUserQuestionBody(body) {
+    const toolUseId = typeof body.toolUseId === 'string' ? body.toolUseId : '';
+    const tabId = typeof body.tabId === 'string' ? body.tabId : '';
+    const questions = parseQuestions(body.questions);
+    if (!toolUseId || !tabId || !questions || questions.length === 0) {
+        return null;
+    }
+    const timeoutMs = typeof body.timeoutMs === 'number' && body.timeoutMs > 0 ? body.timeoutMs : undefined;
+    return { toolUseId, tabId, questions, timeoutMs };
+}
+async function resolveAskUserQuestion(ctx, parsed) {
+    const { toolUseId, tabId, questions, timeoutMs } = parsed;
+    const payload = { toolUseId, questions };
+    broadcastTabEvent(ctx, tabId, 'askUserQuestion', payload);
+    try {
+        const { answers, timedOut } = await registerPendingQuestion({
+            toolUseId,
+            tabId,
+            questions,
+            timeoutMs,
+            computeTimeoutAnswers: () => selectRecommendedAnswers(questions),
+        });
+        if (timedOut) {
+            broadcastTabEvent(ctx, tabId, 'askUserQuestionAutoAnswered', { toolUseId, answers });
+        }
+        return { status: 200, body: { answers } };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : 'cancelled';
+        broadcastTabEvent(ctx, tabId, 'askUserQuestionDismissed', {
+            toolUseId,
+            reason: reason === 'timeout' ? 'timeout' : 'cancelled',
+        });
+        const status = reason === 'timeout' ? 504 : 410;
+        return { status, body: { error: reason } };
+    }
+}
+const CAPABILITY_TOKEN_HEADER = 'x-minionry-capability-token';
+function logContradiction(route, field, claimed, bound) {
+    console.error(`[Internal] ${route}: refused — body ${field}=${JSON.stringify(claimed)} contradicts the capability token's ${JSON.stringify(bound)}`);
+}
+function appToolsContextFrom(capability, body, route) {
+    if (!capability.spaceDir) {
+        console.error(`[Internal] ${route}: refused — the capability token is bound to no Space`);
+        return { ok: false };
+    }
+    if (typeof body.spaceDir === 'string' && body.spaceDir !== capability.spaceDir) {
+        logContradiction(route, 'spaceDir', body.spaceDir, capability.spaceDir);
+        return { ok: false };
+    }
+    if (typeof body.onlyAppId === 'string' && body.onlyAppId !== capability.onlyAppId) {
+        logContradiction(route, 'onlyAppId', body.onlyAppId, capability.onlyAppId);
+        return { ok: false };
+    }
+    return {
+        ok: true,
+        ctx: {
+            spaceDir: capability.spaceDir,
+            ...(capability.onlyAppId ? { onlyAppId: capability.onlyAppId } : {}),
+        },
+    };
+}
+function qualityContextFrom(capability, body, route) {
+    if (!capability.spaceDir) {
+        console.error(`[Internal] ${route}: refused — the capability token is bound to no Space`);
+        return { ok: false };
+    }
+    if (!capability.tabId) {
+        console.error(`[Internal] ${route}: refused — the capability token is bound to no tab session`);
+        return { ok: false };
+    }
+    if (capability.onlyAppId) {
+        console.error(`[Internal] ${route}: refused — an app-confined run is never granted the quality check`);
+        return { ok: false };
+    }
+    if (typeof body.spaceDir === 'string' && body.spaceDir !== capability.spaceDir) {
+        logContradiction(route, 'spaceDir', body.spaceDir, capability.spaceDir);
+        return { ok: false };
+    }
+    return { ok: true, spaceRoot: capability.spaceDir, sessionKey: capability.tabId };
+}
+function toErrorBody(err) {
+    const e = err;
+    const code = typeof e?.code === 'string' ? e.code : 'internal_error';
+    const message = typeof e?.message === 'string' ? e.message : 'browser op failed';
+    const data = e?.currentOwner !== undefined
+        ? { currentOwner: e.currentOwner }
+        : e?.details !== undefined
+            ? e.details
+            : undefined;
+    const status = code === 'tab_already_leased'
+        ? 409
+        : code === 'browser_host_unavailable'
+            ? 503
+            : code === 'invalid_params'
+                ? 400
+                : 500;
+    return { body: { error: { code, message, ...(data !== undefined ? { data } : {}) } }, status };
+}
+class InvalidParamsError extends Error {
+    code = 'invalid_params';
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidParamsError';
+    }
+}
+function requireString(params, name) {
+    const v = params?.[name];
+    if (typeof v !== 'string' || !v) {
+        throw new InvalidParamsError(`missing required string param: ${name}`);
+    }
+    return v;
+}
+function optionalString(params, name) {
+    const v = params?.[name];
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v !== 'string') {
+        throw new InvalidParamsError(`expected string for param: ${name}`);
+    }
+    return v;
+}
+function viewTabId(host, params) {
+    const named = optionalString(params, 'tabId');
+    return named ? host.resolveAgentTabId(named) : undefined;
+}
+function requireStringArray(params, name) {
+    const v = params?.[name];
+    if (!Array.isArray(v) || v.some((x) => typeof x !== 'string')) {
+        throw new InvalidParamsError(`missing required string[] param: ${name}`);
+    }
+    return v;
+}
+function requireFormFields(params, name) {
+    const v = params?.[name];
+    if (!Array.isArray(v)) {
+        throw new InvalidParamsError(`missing required FormField[] param: ${name}`);
+    }
+    return v.map((raw, i) => {
+        if (!raw || typeof raw !== 'object') {
+            throw new InvalidParamsError(`${name}[${i}] is not an object`);
+        }
+        const r = raw;
+        if (typeof r.ref !== 'string' || typeof r.value !== 'string') {
+            throw new InvalidParamsError(`${name}[${i}] needs string ref + value`);
+        }
+        return { ref: r.ref, value: r.value };
+    });
+}
+export function resolveSpaceAgentId(spaceIdentity) {
+    if (spaceIdentity === undefined || spaceIdentity === null)
+        return null;
+    if (typeof spaceIdentity !== 'object') {
+        throw new InvalidParamsError('spaceIdentity must be an object');
+    }
+    const s = spaceIdentity;
+    if (typeof s.clientId !== 'string' || !s.clientId) {
+        throw new InvalidParamsError('spaceIdentity.clientId must be a non-empty string');
+    }
+    if (typeof s.workingDirectory !== 'string' || !s.workingDirectory) {
+        throw new InvalidParamsError('spaceIdentity.workingDirectory must be a non-empty string');
+    }
+    return deriveSpaceBrowserAgentId(s.clientId, s.workingDirectory);
+}
+const BROWSER_OP_HANDLERS = {
+    'agent.tab.lease': (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const agentId = requireString(p, 'agentId');
+        const planId = optionalString(p, 'planId');
+        const ttlMs = typeof p.ttlMs === 'number' ? p.ttlMs : undefined;
+        return host.leaseTab({
+            tabId,
+            agentId,
+            ...(planId !== undefined ? { planId } : {}),
+            ...(ttlMs !== undefined ? { ttlMs } : {}),
+        });
+    },
+    'agent.tab.release': (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const agentId = requireString(p, 'agentId');
+        return host.releaseTab({ tabId, agentId });
+    },
+    'agent.tab.heartbeat': (host, p) => {
+        const agentId = requireString(p, 'agentId');
+        const tabIds = requireStringArray(p, 'tabIds');
+        const ttlMs = typeof p.ttlMs === 'number' ? p.ttlMs : undefined;
+        return host.heartbeat({
+            agentId,
+            tabIds,
+            ...(ttlMs !== undefined ? { ttlMs } : {}),
+        });
+    },
+    'agent.tab.list': (host, p) => {
+        const filter = {};
+        const agentId = optionalString(p, 'agentId');
+        const planId = optionalString(p, 'planId');
+        if (agentId !== undefined)
+            filter.agentId = agentId;
+        if (planId !== undefined)
+            filter.planId = planId;
+        return host.listLeases(filter);
+    },
+    'agent.plan.release': (host, p) => {
+        const planId = requireString(p, 'planId');
+        return host.releasePlan(planId);
+    },
+    'tab.open': (host, p) => {
+        const url = requireString(p, 'url');
+        return host.openTab(url);
+    },
+    'tab.close': async (host, p) => {
+        const id = requireString(p, 'id');
+        await host.closeTab(id);
+        return null;
+    },
+    'tab.select': async (host, p) => {
+        const id = requireString(p, 'id');
+        await host.switchTab(id);
+        return null;
+    },
+    'tab.list': (host, p) => {
+        const tabIds = Array.isArray(p.tabIds) ? p.tabIds : [];
+        const out = [];
+        for (const t of tabIds) {
+            if (typeof t !== 'string')
+                continue;
+            out.push({ tabId: t, info: host.getTabInfo(t) });
+        }
+        return out;
+    },
+    'view.navigate': async (host, p) => {
+        const url = requireString(p, 'url');
+        await host.navigate(url, viewTabId(host, p));
+        return null;
+    },
+    'view.back': async (host, p) => {
+        await host.goBack(viewTabId(host, p));
+        return null;
+    },
+    'view.forward': async (host, p) => {
+        await host.goForward(viewTabId(host, p));
+        return null;
+    },
+    'view.reload': async (host, p) => {
+        await host.reload(viewTabId(host, p));
+        return null;
+    },
+    'dom.snapshot': (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        return host.dom.snapshot({ tabId });
+    },
+    'dom.click': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const ref = requireString(p, 'ref');
+        const button = (() => {
+            const b = p.button;
+            if (b === 'left' || b === 'right' || b === 'middle')
+                return b;
+            return undefined;
+        })();
+        const clickCount = typeof p.clickCount === 'number' ? p.clickCount : undefined;
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.click({
+            tabId,
+            ref,
+            ...(button !== undefined ? { button } : {}),
+            ...(clickCount !== undefined ? { clickCount } : {}),
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.type': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const ref = requireString(p, 'ref');
+        const text = requireString(p, 'text');
+        const submit = p.submit === true;
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.type({
+            tabId,
+            ref,
+            text,
+            submit,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.hover': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const ref = requireString(p, 'ref');
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.hover({
+            tabId,
+            ref,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.press_key': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const key = requireString(p, 'key');
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.pressKey({
+            tabId,
+            key,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.select_option': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const ref = requireString(p, 'ref');
+        const values = requireStringArray(p, 'values');
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.selectOption({
+            tabId,
+            ref,
+            values,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.fill_form': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const fields = requireFormFields(p, 'fields');
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.fillForm({
+            tabId,
+            fields,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.drag_drop': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const fromRef = requireString(p, 'fromRef');
+        const toRef = requireString(p, 'toRef');
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.dragDrop({
+            tabId,
+            fromRef,
+            toRef,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.file_upload': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const ref = requireString(p, 'ref');
+        const paths = requireStringArray(p, 'paths');
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.fileUpload({
+            tabId,
+            ref,
+            paths,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.handle_dialog': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const accept = p.accept === true;
+        const promptText = optionalString(p, 'promptText');
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.handleDialog({
+            tabId,
+            accept,
+            ...(promptText !== undefined ? { promptText } : {}),
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.wait_for': async (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const timeoutMs = typeof p.timeoutMs === 'number' ? p.timeoutMs : 5000;
+        const pollIntervalMs = typeof p.pollIntervalMs === 'number' ? p.pollIntervalMs : undefined;
+        const conditionRaw = p.condition;
+        if (!conditionRaw || typeof conditionRaw !== 'object') {
+            throw new InvalidParamsError('missing condition for wait_for');
+        }
+        const condition = conditionRaw.type === 'expression' && typeof conditionRaw.expr === 'string'
+            ? { type: 'expression', expr: conditionRaw.expr }
+            : conditionRaw.type === 'navigation'
+                ? { type: 'navigation' }
+                : null;
+        if (!condition) {
+            throw new InvalidParamsError('wait_for condition must be {type:"expression",expr} or {type:"navigation"}');
+        }
+        const agentId = optionalString(p, 'agentId');
+        await host.dom.waitFor({
+            tabId,
+            timeoutMs,
+            ...(pollIntervalMs !== undefined ? { pollIntervalMs } : {}),
+            condition,
+            ...(agentId !== undefined ? { agentId } : {}),
+        });
+        return null;
+    },
+    'dom.screenshot': (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const format = p.format === 'jpeg' ? 'jpeg' : p.format === 'png' ? 'png' : undefined;
+        const quality = typeof p.quality === 'number' ? p.quality : undefined;
+        const fullPage = p.fullPage === true;
+        const clip = p.clip ?? undefined;
+        const clipShape = clip &&
+            typeof clip.x === 'number' &&
+            typeof clip.y === 'number' &&
+            typeof clip.width === 'number' &&
+            typeof clip.height === 'number'
+            ? {
+                x: clip.x,
+                y: clip.y,
+                width: clip.width,
+                height: clip.height,
+            }
+            : undefined;
+        return host.dom.screenshot({
+            tabId,
+            fullPage,
+            ...(format !== undefined ? { format } : {}),
+            ...(quality !== undefined ? { quality } : {}),
+            ...(clipShape !== undefined ? { clip: clipShape } : {}),
+        });
+    },
+    'dom.console': (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const since = typeof p.since === 'number' ? p.since : undefined;
+        return host.dom.console({
+            tabId,
+            ...(since !== undefined ? { since } : {}),
+        });
+    },
+    'dom.network': (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const since = typeof p.since === 'number' ? p.since : undefined;
+        return host.dom.network({
+            tabId,
+            ...(since !== undefined ? { since } : {}),
+        });
+    },
+    'js.evaluate': (host, p) => {
+        const tabId = requireString(p, 'tabId');
+        const expr = requireString(p, 'expr');
+        const world = p.world === 'main' ? 'main' : 'isolated';
+        const timeoutMs = typeof p.timeoutMs === 'number' ? p.timeoutMs : undefined;
+        return host.js.evaluate({
+            tabId,
+            expr,
+            world,
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        });
+    },
+};
+export async function dispatchBrowserOp(host, req) {
+    const handler = BROWSER_OP_HANDLERS[req.method];
+    if (!handler) {
+        throw new InvalidParamsError(`unknown browser op method: ${req.method}`);
+    }
+    return handler(host, req.params ?? {});
+}
+function browserIdentityFrom(capability, body, route) {
+    if (!capability.agentId) {
+        console.error(`[Internal] ${route}: refused — the capability token is bound to no browser agent`);
+        return { ok: false };
+    }
+    const params = body.params ?? {};
+    for (const field of ['agentId', 'planId', 'agentSessionId']) {
+        const claimed = params[field];
+        if (typeof claimed === 'string' && claimed !== capability[field]) {
+            logContradiction(route, `params.${field}`, claimed, capability[field]);
+            return { ok: false };
+        }
+    }
+    if (body.spaceIdentity !== undefined && body.spaceIdentity !== null) {
+        let derived = null;
+        try {
+            derived = resolveSpaceAgentId(body.spaceIdentity);
+        }
+        catch {
+            derived = null;
+        }
+        if (derived !== capability.agentId) {
+            logContradiction(route, 'spaceIdentity', body.spaceIdentity, capability.agentId);
+            return { ok: false };
+        }
+    }
+    return { ok: true, identity: identityOf(capability, capability.agentId) };
+}
+function identityOf(capability, agentId) {
+    return {
+        agentId,
+        ...(capability.planId ? { planId: capability.planId } : {}),
+        ...(capability.defaultTabId ? { defaultTabId: capability.defaultTabId } : {}),
+        ...(capability.agentSessionId ? { agentSessionId: capability.agentSessionId } : {}),
+        ...(capability.agentLabel ? { agentLabel: capability.agentLabel } : {}),
+    };
+}
+function bindBrowserOp(body, identity) {
+    const params = { ...(body.params ?? {}) };
+    params.agentId = identity.agentId;
+    if (identity.planId !== undefined)
+        params.planId = identity.planId;
+    if (typeof params.tabId !== 'string' || !params.tabId) {
+        if (identity.defaultTabId !== undefined)
+            params.tabId = identity.defaultTabId;
+        else
+            delete params.tabId;
+    }
+    return { method: body.method, params };
+}
+async function reflectBrowserLeaseOp(ctx, host, op, result, identity) {
+    try {
+        if (op.method === 'agent.tab.lease') {
+            const lease = result;
+            getBrowserDriverState().setOwner(lease.tabId, leaseOwnerFor(identity, lease.leasedUntil));
+            await broadcastLeaseRoster(ctx, host, identity);
+        }
+        else if (op.method === 'agent.tab.heartbeat') {
+            await refreshHeldOwners(host, identity, result.stillLeased);
+        }
+        else if (op.method === 'agent.tab.release' && result.released) {
+            const tabId = op.params?.tabId;
+            if (typeof tabId === 'string')
+                getBrowserDriverState().clearOwner(tabId);
+            await broadcastLeaseRoster(ctx, host, identity);
+        }
+    }
+    catch (err) {
+        console.error(`[Internal] /browser/op: ${op.method} succeeded but its owner/roster mirror failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+const AGENT_DRIVING_OPS = {
+    'dom.click': 'browser_click',
+    'dom.type': 'browser_type',
+    'dom.hover': 'browser_hover',
+    'dom.press_key': 'browser_press_key',
+    'dom.select_option': 'browser_select_option',
+    'dom.fill_form': 'browser_fill_form',
+    'dom.drag_drop': 'browser_drag',
+    'dom.file_upload': 'browser_file_upload',
+    'dom.handle_dialog': 'browser_handle_dialog',
+    'view.navigate': 'browser_navigate',
+    'view.back': 'browser_back',
+    'view.forward': 'browser_forward',
+    'view.reload': 'browser_reload',
+};
+function drivenTabId(host, op) {
+    const named = op.params?.tabId;
+    if (typeof named === 'string' && named)
+        return host.resolveAgentTabId(named);
+    return op.method.startsWith('dom.') ? null : host.getTabsSnapshot().currentTabId;
+}
+function arbitrationRefusal(host, op) {
+    const tool = AGENT_DRIVING_OPS[op.method];
+    if (!tool || !INPUT_MUTATING_BROWSER_TOOLS.has(tool))
+        return null;
+    const tabId = drivenTabId(host, op);
+    if (!tabId)
+        return null;
+    const gate = getBrowserDriverState().gateSync(tabId, tool);
+    if (gate.allow)
+        return null;
+    console.error(`[Internal] /browser/op: ${op.method} on tab ${tabId.slice(0, 8)} deferred by driver arbitration (${gate.state})`);
+    return { error: { code: gate.code, message: gate.hint, data: { state: gate.state, since: gate.since } } };
+}
+function reflectAgentDriving(host, op) {
+    if (!(op.method in AGENT_DRIVING_OPS))
+        return;
+    try {
+        const tabId = drivenTabId(host, op);
+        if (tabId && host.getTabInfo(tabId))
+            getBrowserDriverState().recordInput(tabId, 'agent');
+    }
+    catch (err) {
+        console.error(`[Internal] /browser/op: ${op.method} succeeded but its driver-state mark failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function leaseOwnerFor(identity, leasedUntil) {
+    return {
+        ownerAgentId: identity.agentId,
+        ownerAgentLabel: identity.agentLabel ?? identity.agentId,
+        ...(identity.planId ? { planId: identity.planId } : {}),
+        leasedUntil,
+        ...(identity.agentSessionId ? { ownerSessionId: identity.agentSessionId } : {}),
+    };
+}
+function broadcastLeaseRoster(ctx, host, identity) {
+    return broadcastAgentTabState(host, ctx, identity.agentId, identity.agentLabel ?? identity.agentId, identity.agentSessionId ? { sessionId: identity.agentSessionId } : {});
+}
+async function refreshHeldOwners(host, identity, stillLeased) {
+    if (stillLeased.length === 0)
+        return;
+    const held = new Set(stillLeased);
+    for (const lease of await host.listLeases({ agentId: identity.agentId })) {
+        if (held.has(lease.tabId)) {
+            getBrowserDriverState().setOwner(lease.tabId, leaseOwnerFor(identity, lease.leasedUntil));
+        }
+    }
+}
+function isLoopbackAddress(address) {
+    if (!address)
+        return false;
+    if (address === '::1')
+        return true;
+    const v4 = address.startsWith('::ffff:') ? address.slice('::ffff:'.length) : address;
+    return /^127\./.test(v4);
+}
+function remoteAddressOf(c) {
+    try {
+        return getConnInfo(c).remote.address;
+    }
+    catch {
+        return undefined;
+    }
+}
+function requireLoopback() {
+    return async (c, next) => {
+        if (!isLoopbackAddress(remoteAddressOf(c))) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        await next();
+    };
+}
+function requireChildCapability() {
+    return async (c, next) => {
+        if (!isValidBouncerSecret(c.req.header('x-minionry-bouncer-secret'))) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        if (!resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER))) {
+            console.error(`[Internal] ${c.req.path}: refused — no live capability token (absent, unknown, revoked or expired)`);
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        await next();
+    };
+}
+const DECISION_CACHE_MAX_ENTRIES = 1000;
+const DECISION_CACHE_MAX_TTL_MS = 60 * 60 * 1000;
+const decisionCache = new Map();
+function decisionCacheKey(capability, key) {
+    return `${capability.spaceDir}\0${capability.tabId ?? ''}\0${key}`;
+}
+export function _resetDecisionCacheForTests() {
+    decisionCache.clear();
+}
+function parseVerdict(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const verdict = value;
+    if (!['allow', 'warn_allow', 'deny'].includes(String(verdict.decision)))
+        return null;
+    if (typeof verdict.confidence !== 'number' || !Number.isFinite(verdict.confidence))
+        return null;
+    return verdict;
+}
+function parseDecisionCachePut(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const { key, decision, ttlMs } = body;
+    if (typeof key !== 'string' || key.length === 0)
+        return null;
+    const verdict = parseVerdict(decision);
+    if (!verdict)
+        return null;
+    const requested = typeof ttlMs === 'number' && Number.isFinite(ttlMs) ? ttlMs : DECISION_CACHE_MAX_TTL_MS;
+    return { key, decision: verdict, ttlMs: Math.max(0, Math.min(requested, DECISION_CACHE_MAX_TTL_MS)) };
+}
+export function createInternalRoutes(ctx) {
+    const app = new Hono();
+    app.use('*', requireLoopback());
+    app.use('*', requireChildCapability());
+    app.get('/bouncer/decision-cache', (c) => {
+        const capability = resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER));
+        if (!capability) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        const key = c.req.query('key');
+        if (!key) {
+            return c.json({ error: 'key is required' }, 400);
+        }
+        const namespaced = decisionCacheKey(capability, key);
+        const entry = decisionCache.get(namespaced);
+        if (!entry) {
+            return c.json({ decision: null });
+        }
+        if (entry.expiresAt <= Date.now()) {
+            decisionCache.delete(namespaced);
+            return c.json({ decision: null });
+        }
+        return c.json({ decision: entry.decision });
+    });
+    app.put('/bouncer/decision-cache', async (c) => {
+        const capability = resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER));
+        if (!capability) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON' }, 400);
+        }
+        const parsed = parseDecisionCachePut(body);
+        if (!parsed) {
+            return c.json({ error: 'key and a well-formed decision are required' }, 400);
+        }
+        const namespaced = decisionCacheKey(capability, parsed.key);
+        decisionCache.delete(namespaced);
+        if (decisionCache.size >= DECISION_CACHE_MAX_ENTRIES) {
+            const oldest = decisionCache.keys().next().value;
+            if (oldest !== undefined)
+                decisionCache.delete(oldest);
+        }
+        decisionCache.set(namespaced, { decision: parsed.decision, expiresAt: Date.now() + parsed.ttlMs });
+        return c.json({ ok: true });
+    });
+    app.post('/ask-user-question', async (c) => {
+        const capability = resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER));
+        if (!capability) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON' }, 400);
+        }
+        const parsed = parseAskUserQuestionBody(body);
+        if (!parsed) {
+            return c.json({ error: 'toolUseId, tabId, and non-empty questions[] are required' }, 400);
+        }
+        if (!capability.tabId || parsed.tabId !== capability.tabId) {
+            logContradiction('/ask-user-question', 'tabId', parsed.tabId, capability.tabId);
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        const { status, body: responseBody } = await resolveAskUserQuestion(ctx, {
+            ...parsed,
+            tabId: capability.tabId,
+        });
+        return c.json(responseBody, status);
+    });
+    app.post('/app-tools/list', async (c) => {
+        const capability = resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER));
+        if (!capability) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON' }, 400);
+        }
+        const resolved = appToolsContextFrom(capability, body, '/app-tools/list');
+        if (!resolved.ok) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        return c.json({ tools: listExposedAppTools(resolved.ctx) });
+    });
+    app.post('/app-tools/call', async (c) => {
+        const capability = resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER));
+        if (!capability) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON' }, 400);
+        }
+        const resolved = appToolsContextFrom(capability, body, '/app-tools/call');
+        if (!resolved.ok) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        const name = typeof body.name === 'string' ? body.name : '';
+        if (!name) {
+            return c.json({ error: 'name is required' }, 400);
+        }
+        const input = typeof body.input === 'object' && body.input !== null && !Array.isArray(body.input)
+            ? body.input
+            : {};
+        return c.json(await invokeExposedAppTool({ ctx: resolved.ctx, name, input }));
+    });
+    app.post('/quality/check', async (c) => {
+        const capability = resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER));
+        if (!capability) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON' }, 400);
+        }
+        const resolved = qualityContextFrom(capability, body, '/quality/check');
+        if (!resolved.ok) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        const parsed = parseQualityCheckPaths(body);
+        if (!parsed.ok) {
+            return c.json(parsed);
+        }
+        return c.json(await runQualityCheck({ spaceRoot: resolved.spaceRoot, paths: parsed.paths, sessionKey: resolved.sessionKey }));
+    });
+    app.post('/browser/op', async (c) => {
+        const capability = resolveMcpCapability(c.req.header(CAPABILITY_TOKEN_HEADER));
+        if (!capability) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: 'Invalid JSON' }, 400);
+        }
+        if (!body || typeof body.method !== 'string') {
+            return c.json({ error: { code: 'invalid_params', message: 'method is required' } }, 400);
+        }
+        const resolved = browserIdentityFrom(capability, body, '/browser/op');
+        if (!resolved.ok) {
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        const host = ctx.getBrowserHost();
+        if (!host) {
+            return c.json({
+                error: {
+                    code: 'browser_host_unavailable',
+                    message: 'BrowserHost is not attached to this CLI server',
+                },
+            }, 503);
+        }
+        const bound = bindBrowserOp(body, resolved.identity);
+        const refusal = arbitrationRefusal(host, bound);
+        if (refusal) {
+            return c.json(refusal, 409);
+        }
+        try {
+            const result = await dispatchBrowserOp(host, bound);
+            reflectAgentDriving(host, bound);
+            await reflectBrowserLeaseOp(ctx, host, bound, result, resolved.identity);
+            return c.json({ result });
+        }
+        catch (err) {
+            const { body: errBody, status } = toErrorBody(err);
+            return c.json(errBody, status);
+        }
+    });
+    return app;
+}