@minionry/minion 0.7.36

package/dist/server/services/sdk/test-utils/workshop-browser-app.js

@@ -0,0 +1,466 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createProvider } from '@minionry/sdk';
+import { getClientId } from '../../client-id.js';
+import { makeSpaceKey } from '../../settings.js';
+import { resolveSdkConsent } from '../connect.js';
+import { runSdkPipeline } from '../pipeline.js';
+import { SDK_METHOD_REGISTRY } from '../registry.js';
+export const WORKSHOP_BROWSER_CORE_TOOLS = [
+    'tabs_list',
+    'tabs_open',
+    'tabs_close',
+    'tabs_select',
+    'navigate',
+    'snapshot',
+    'act',
+];
+export const WORKSHOP_BROWSER_RECOMMENDED_TOOLS = ['history', 'screenshot', 'evaluate'];
+export const WORKSHOP_BROWSER_TOOLS = [
+    ...WORKSHOP_BROWSER_CORE_TOOLS,
+    ...WORKSHOP_BROWSER_RECOMMENDED_TOOLS,
+];
+export const WORKSHOP_BROWSER_SUCCEEDS = {
+    tabs_list: 'browser.tabs.list',
+    tabs_open: 'browser.tabs.open',
+    tabs_close: 'browser.tabs.close',
+    tabs_select: 'browser.tabs.select',
+    navigate: 'browser.navigate',
+    snapshot: 'browser.snapshot',
+    act: 'browser.act',
+    history: 'browser.history',
+    screenshot: 'browser.screenshot',
+    evaluate: 'browser.evaluate',
+};
+function titleFor(url) {
+    if (url === 'about:blank')
+        return 'New Tab';
+    try {
+        const parsed = new URL(url);
+        const leaf = parsed.pathname.split('/').filter(Boolean).pop();
+        return leaf ? `${leaf} — ${parsed.hostname}` : parsed.hostname;
+    }
+    catch {
+        return url;
+    }
+}
+function nextUrlFor(url) {
+    return url === 'about:blank' ? 'https://fixture.test/home' : `${url}/next`;
+}
+export class FixturePage {
+    tabs = [{ id: 'tab-1', url: 'about:blank', title: 'New Tab', back: [], forward: [] }];
+    activeTabId = 'tab-1';
+    epoch = 1;
+    typed = new Map();
+    acts = [];
+    screenshots = 0;
+    nextTabSeq = 2;
+    active() {
+        const tab = this.tabs.find((candidate) => candidate.id === this.activeTabId);
+        if (!tab)
+            throw new Error('no active tab');
+        return tab;
+    }
+    open(url) {
+        const tab = { id: `tab-${this.nextTabSeq++}`, url, title: titleFor(url), back: [], forward: [] };
+        this.tabs.push(tab);
+        this.activeTabId = tab.id;
+        this.epoch += 1;
+        return tab;
+    }
+    close(tabId) {
+        if (this.tabs.length === 1)
+            throw new Error(`refusing to close '${tabId}': it is the last open tab`);
+        const at = this.tabs.findIndex((candidate) => candidate.id === tabId);
+        if (at < 0)
+            throw new Error(`no tab '${tabId}'`);
+        this.tabs.splice(at, 1);
+        if (this.activeTabId === tabId)
+            this.activeTabId = this.tabs[Math.max(0, at - 1)].id;
+    }
+    select(tabId) {
+        const tab = this.tabs.find((candidate) => candidate.id === tabId);
+        if (!tab)
+            throw new Error(`no tab '${tabId}'`);
+        this.activeTabId = tabId;
+        return tab;
+    }
+    navigate(url) {
+        const tab = this.active();
+        tab.back.push(tab.url);
+        tab.forward = [];
+        tab.url = url;
+        tab.title = titleFor(url);
+        this.epoch += 1;
+        return tab;
+    }
+    go(direction) {
+        const tab = this.active();
+        const from = direction === 'back' ? tab.back : tab.forward;
+        const to = direction === 'back' ? tab.forward : tab.back;
+        const url = from.pop();
+        if (url === undefined)
+            throw new Error(`nothing to go ${direction} to`);
+        to.push(tab.url);
+        tab.url = url;
+        tab.title = titleFor(url);
+        this.epoch += 1;
+        return tab;
+    }
+    snapshot() {
+        const tab = this.active();
+        const ref = (index) => `e${this.epoch}n${index}`;
+        return {
+            url: tab.url,
+            title: tab.title,
+            epoch: this.epoch,
+            root: {
+                ref: ref(1),
+                role: 'RootWebArea',
+                name: tab.title,
+                children: [
+                    {
+                        ref: ref(2),
+                        role: 'main',
+                        name: 'Fixture page',
+                        children: [
+                            { ref: ref(3), role: 'heading', name: tab.title, level: 1, children: [] },
+                            { ref: ref(4), role: 'link', name: 'Next page', children: [] },
+                            { ref: ref(5), role: 'textbox', name: 'Search', value: this.typed.get(tab.id) ?? '', children: [] },
+                            { ref: ref(6), role: 'button', name: 'Submit', children: [] },
+                        ],
+                    },
+                ],
+            },
+        };
+    }
+    act(ref, action, text) {
+        const tab = this.active();
+        const suffix = ref.split('n').pop();
+        this.acts.push(`${action}:${ref}`);
+        if (action === 'click' && suffix === '4')
+            return this.navigate(nextUrlFor(tab.url));
+        if (action === 'click' && suffix === '6')
+            return tab;
+        if (action === 'type' && suffix === '5') {
+            this.typed.set(tab.id, text ?? '');
+            return tab;
+        }
+        throw new Error(`ref '${ref}' does not accept '${action}' on this page`);
+    }
+    evaluate(expression) {
+        const tab = this.active();
+        switch (expression) {
+            case 'location.href':
+                return tab.url;
+            case 'document.title':
+                return tab.title;
+            case 'window.__fixture.acts':
+                return [...this.acts];
+            case 'window.__fixture.typed':
+                return this.typed.get(tab.id) ?? '';
+            default:
+                throw new Error(`this page does not evaluate '${expression}'`);
+        }
+    }
+}
+function params(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input) ? input : {};
+}
+function str(input, field) {
+    const value = params(input)[field];
+    if (typeof value !== 'string' || value === '')
+        throw new Error(`'${field}' is required`);
+    return value;
+}
+const OBJECT_SCHEMA = { type: 'object', properties: {} };
+function schema(properties, required) {
+    return { type: 'object', properties, required };
+}
+export function buildWorkshopBrowserTools(page) {
+    return [
+        {
+            name: 'tabs_list',
+            description: 'List the open tabs and which one is active.',
+            inputSchema: OBJECT_SCHEMA,
+            handler: () => ({
+                tabs: page.tabs.map((tab) => ({
+                    id: tab.id,
+                    url: tab.url,
+                    title: tab.title,
+                    active: tab.id === page.activeTabId,
+                })),
+            }),
+        },
+        {
+            name: 'tabs_open',
+            description: 'Open a new tab and make it active.',
+            inputSchema: schema({ url: { type: 'string' } }, []),
+            handler: (input) => {
+                const raw = params(input).url;
+                const tab = page.open(typeof raw === 'string' && raw ? raw : 'about:blank');
+                return { tabId: tab.id, url: tab.url, title: tab.title };
+            },
+        },
+        {
+            name: 'tabs_close',
+            description: 'Close one tab by id.',
+            inputSchema: schema({ tabId: { type: 'string' } }, ['tabId']),
+            handler: (input) => {
+                page.close(str(input, 'tabId'));
+                return { closed: true, remaining: page.tabs.length };
+            },
+        },
+        {
+            name: 'tabs_select',
+            description: 'Make one tab active.',
+            inputSchema: schema({ tabId: { type: 'string' } }, ['tabId']),
+            handler: (input) => {
+                const tab = page.select(str(input, 'tabId'));
+                return { tabId: tab.id, url: tab.url, title: tab.title };
+            },
+        },
+        {
+            name: 'navigate',
+            description: 'Load a URL in the active tab.',
+            inputSchema: schema({ url: { type: 'string' } }, ['url']),
+            handler: (input) => {
+                const tab = page.navigate(str(input, 'url'));
+                return { url: tab.url, title: tab.title };
+            },
+        },
+        {
+            name: 'snapshot',
+            description: 'Accessibility-tree snapshot of the active tab, for the agent to read and address.',
+            inputSchema: OBJECT_SCHEMA,
+            handler: () => page.snapshot(),
+        },
+        {
+            name: 'act',
+            description: 'Click or type at one snapshot ref in the active tab.',
+            inputSchema: schema({ ref: { type: 'string' }, action: { type: 'string', enum: ['click', 'type'] }, text: { type: 'string' } }, ['ref', 'action']),
+            handler: (input) => {
+                const action = str(input, 'action');
+                if (action !== 'click' && action !== 'type')
+                    throw new Error(`unsupported action '${action}'`);
+                const text = params(input).text;
+                const tab = page.act(str(input, 'ref'), action, typeof text === 'string' ? text : undefined);
+                return { ok: true, url: tab.url, title: tab.title };
+            },
+        },
+        {
+            name: 'history',
+            description: 'Move the active tab back or forward through its history.',
+            inputSchema: schema({ direction: { type: 'string', enum: ['back', 'forward'] } }, ['direction']),
+            handler: (input) => {
+                const direction = str(input, 'direction');
+                if (direction !== 'back' && direction !== 'forward')
+                    throw new Error(`unsupported direction '${direction}'`);
+                const tab = page.go(direction);
+                return { url: tab.url, title: tab.title };
+            },
+        },
+        {
+            name: 'screenshot',
+            description: 'Visual read of the active tab, as a base64 PNG.',
+            inputSchema: OBJECT_SCHEMA,
+            handler: () => {
+                page.screenshots += 1;
+                const tab = page.active();
+                return {
+                    format: 'png',
+                    width: 800,
+                    height: 600,
+                    base64: Buffer.from(`fixture-screenshot:${tab.url}`, 'utf8').toString('base64'),
+                };
+            },
+        },
+        {
+            name: 'evaluate',
+            description: 'Read one whitelisted value out of the active page.',
+            inputSchema: schema({ expression: { type: 'string' } }, ['expression']),
+            handler: (input) => ({ value: page.evaluate(str(input, 'expression')) }),
+        },
+    ];
+}
+const REQUEST_ID_PARAM_METHODS = new Set(['cancel', 'stream.resume']);
+export function createInProcessSdkTransport(options) {
+    let handlers;
+    let closed = false;
+    const wireRequestId = (localRequestId) => `${options.instanceId}:${localRequestId}`;
+    const decodeWireRequestId = (wireId) => {
+        const at = wireId.indexOf(':');
+        if (at <= 0)
+            return null;
+        return Number(wireId.slice(0, at)) === options.instanceId ? wireId.slice(at + 1) : null;
+    };
+    const encodeRequestIdParams = (method, raw) => {
+        if (!REQUEST_ID_PARAM_METHODS.has(method))
+            return raw;
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            return raw;
+        const requestId = raw.requestId;
+        if (typeof requestId !== 'string')
+            return raw;
+        return { ...raw, requestId: wireRequestId(requestId) };
+    };
+    const answerConsent = (card) => {
+        const answer = options.onConsent
+            ? options.onConsent(card)
+            : { approved: true, granted: card.requestedScopes, remember: true };
+        if (!answer)
+            return;
+        resolveSdkConsent(card.consentId, {
+            approved: answer.approved,
+            granted: answer.approved ? (answer.granted ?? card.requestedScopes) : [],
+            remember: answer.remember ?? true,
+        }, { role: options.role, viewerId: options.viewerId });
+    };
+    const routeSessionFrame = (frame) => {
+        options.onSessionFrame?.(frame);
+        if (frame.type === 'sdkConsentRequest') {
+            answerConsent(frame.data);
+            return;
+        }
+        if (frame.type === 'sdkGrantsChanged') {
+            handlers?.onNotification({ event: 'grantsChanged', payload: frame.data.grants });
+            return;
+        }
+        const local = decodeWireRequestId(frame.data.requestId);
+        if (local === null)
+            return;
+        const payload = frame.data;
+        const toolCall = payload.op === 'call'
+            ? {
+                op: 'call',
+                callId: payload.callId,
+                requestId: local,
+                tool: payload.tool,
+                ...(payload.input !== undefined ? { input: payload.input } : {}),
+            }
+            : { op: 'cancel', callId: payload.callId, requestId: local };
+        handlers?.onToolCall?.(toolCall);
+    };
+    const deliverResponse = (localRequestId, payload) => {
+        if (closed)
+            return;
+        handlers?.onResponse(payload.ok
+            ? { requestId: localRequestId, ok: true, result: payload.result }
+            : { requestId: localRequestId, ok: false, error: payload.error });
+    };
+    return {
+        start(next) {
+            handlers = next;
+        },
+        send(frame) {
+            if (closed)
+                throw new Error('fixture transport is closed');
+            const wireType = SDK_METHOD_REGISTRY[frame.method]?.type ?? 'sdkRequest';
+            void runSdkPipeline({
+                wireType,
+                appId: options.appId,
+                origin: options.origin,
+                requestId: wireRequestId(frame.requestId),
+                method: frame.method,
+                params: encodeRequestIdParams(frame.method, frame.params),
+                role: options.role,
+                viewerId: options.viewerId,
+                tabId: options.tabId,
+                workingDir: options.workingDir,
+                ...(wireType === 'sdkConnect' ? { manifest: options.manifest } : {}),
+                emit: (event, payload, seq) => {
+                    if (!closed)
+                        handlers?.onEvent({ requestId: frame.requestId, event, payload, seq });
+                },
+                notify: routeSessionFrame,
+            }).then((payload) => deliverResponse(frame.requestId, payload));
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            handlers?.onClose();
+        },
+        deliverBroadcast(response) {
+            if (closed || response.type !== 'sdkEvent')
+                return;
+            const data = response.data;
+            const local = decodeWireRequestId(data.requestId);
+            if (local === null)
+                return;
+            handlers?.onEvent({ requestId: local, event: data.event, payload: data.payload, seq: data.seq });
+        },
+        wireRequestId,
+    };
+}
+const DEFAULT_MANIFEST_SCOPES = ['tools:serve', 'agents:run', 'agents:sessions'];
+export function createFixtureWorkshopBrowser(options) {
+    const appId = options.appId ?? 'fixture-browser-abc123def456';
+    const origin = options.origin ?? 'https://fixture-browser.example.com';
+    const viewerId = options.viewerId ?? 'viewer-fixture-device';
+    const manifestScopes = options.manifestScopes ?? DEFAULT_MANIFEST_SCOPES;
+    const manifest = { hash: 'f'.repeat(64), scopes: [...manifestScopes], optionalScopes: [] };
+    const page = new FixturePage();
+    const sessionFrames = [];
+    const toolCalls = [];
+    const served = [];
+    const stalls = new Map();
+    const transport = createInProcessSdkTransport({
+        appId,
+        origin,
+        workingDir: options.workingDir,
+        viewerId,
+        role: options.role ?? 'owner',
+        tabId: options.tabId ?? '__app_host__',
+        instanceId: options.instanceId ?? 1,
+        manifest,
+        onConsent: options.onConsent,
+        onSessionFrame: (frame) => {
+            sessionFrames.push(frame);
+            if (frame.type === 'sdkToolCall')
+                toolCalls.push(frame.data);
+        },
+    });
+    const minionry = createProvider(transport);
+    const instrument = (definition) => ({
+        ...definition,
+        handler: async (input, ctx) => {
+            served.push(definition.name);
+            const stall = stalls.get(definition.name);
+            if (stall)
+                await stall;
+            return definition.handler(input, ctx);
+        },
+    });
+    return {
+        appId,
+        origin,
+        viewerId,
+        workingDir: options.workingDir,
+        spaceKey: makeSpaceKey(getClientId(), options.workingDir),
+        minionry,
+        page,
+        sessionFrames,
+        toolCalls,
+        served,
+        manifest,
+        connect: (scopes) => minionry.connect({ scopes }),
+        serve: () => minionry.tools.register({
+            tools: buildWorkshopBrowserTools(page).map(instrument),
+            profile: 'browser',
+        }),
+        deliverBroadcast: (response) => transport.deliverBroadcast(response),
+        closeTransport: () => transport.close(),
+        wireRequestId: (localRequestId) => transport.wireRequestId(localRequestId),
+        stall(tool) {
+            let release = () => { };
+            stalls.set(tool, new Promise((resolve) => {
+                release = resolve;
+            }));
+            return () => {
+                stalls.delete(tool);
+                release();
+            };
+        },
+    };
+}

package/dist/server/services/sentry.js

@@ -0,0 +1,99 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync } from 'node:fs';
+import { createStackParser, createTransport, initAndBind, nodeStackLineParser, ServerRuntimeClient, captureException as sentryCaptureException, captureMessage as sentryCaptureMessage, flush as sentryFlush, } from '@sentry/core';
+import { machineFile } from '../../bin/machine-layout.js';
+import { resolvePlatformUrl } from './platform-url.js';
+const SENTRY_TUNNEL_DSN = 'https://tunnel@sentry.io/0';
+const PLATFORM_URL = resolvePlatformUrl();
+let initialized = false;
+function isTelemetryEnabled() {
+    const envValue = process.env.MINIONRY_TELEMETRY;
+    if (envValue === '0' || envValue === 'false') {
+        return false;
+    }
+    const configFile = machineFile('telemetry');
+    if (existsSync(configFile)) {
+        try {
+            const config = JSON.parse(readFileSync(configFile, 'utf-8'));
+            if (config.telemetry === false) {
+                return false;
+            }
+        }
+        catch {
+        }
+    }
+    return true;
+}
+async function fetchSentryEnabled() {
+    try {
+        const response = await fetch(`${PLATFORM_URL}/api/config/client`);
+        if (!response.ok)
+            return false;
+        const data = await response.json();
+        return data.errorTracking?.sentryEnabled === true;
+    }
+    catch {
+        return false;
+    }
+}
+function makeFetchTransport(options) {
+    return createTransport(options, async (request) => {
+        try {
+            const response = await fetch(options.url, {
+                method: 'POST',
+                body: request.body,
+                headers: options.headers,
+            });
+            return {
+                statusCode: response.status,
+                headers: {
+                    'x-sentry-rate-limits': response.headers.get('x-sentry-rate-limits'),
+                    'retry-after': response.headers.get('retry-after'),
+                },
+            };
+        }
+        catch {
+            return {};
+        }
+    });
+}
+export async function initSentry() {
+    if (initialized)
+        return;
+    if (!isTelemetryEnabled())
+        return;
+    if (!(await fetchSentryEnabled()) || initialized)
+        return;
+    initialized = true;
+    initAndBind(ServerRuntimeClient, {
+        dsn: SENTRY_TUNNEL_DSN,
+        tunnel: `${PLATFORM_URL}/sentry-tunnel`,
+        environment: process.env.NODE_ENV || 'development',
+        release: `minionry-cli@${process.env.npm_package_version || '0.0.0'}`,
+        integrations: [],
+        transport: makeFetchTransport,
+        stackParser: createStackParser(nodeStackLineParser()),
+        beforeSend(event) {
+            if (event.user) {
+                delete event.user.ip_address;
+            }
+            return event;
+        },
+    });
+}
+export function captureException(error, context) {
+    if (!initialized)
+        return;
+    sentryCaptureException(error, context ? { extra: context } : undefined);
+}
+export function captureMessage(message, level = 'info') {
+    if (!initialized)
+        return;
+    sentryCaptureMessage(message, level);
+}
+export async function flushSentry(timeout = 2000) {
+    if (!initialized)
+        return;
+    await sentryFlush(timeout);
+}