@minionry/minion 0.7.36

package/dist/server/mcp/test-utils/e2e-gating.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { describe, it } from 'vitest';
+export function isE2EEnabled() {
+    return process.env.MINIONRY_E2E === '1';
+}
+export const describeE2E = describe.skipIf(!isE2EEnabled());
+export const itE2E = it.skipIf(!isE2EEnabled());

package/dist/server/mcp/test-utils/e2e-harness.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export * from './e2e-agent.js';
+export * from './e2e-capture.js';
+export * from './e2e-client.js';
+export * from './e2e-fixtures.js';
+export * from './e2e-gating.js';
+export * from './e2e-scenarios.js';

package/dist/server/mcp/test-utils/e2e-scenarios.js

@@ -0,0 +1,105 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export async function driveAgentJourney(agent, steps) {
+    const out = { steps: [] };
+    for (const step of steps) {
+        const result = await agent.runTool(step.tool, step.args);
+        out.steps.push({ step, result });
+        if (result.isError) {
+            const label = step.label ?? step.tool;
+            const text = result.content[0] && result.content[0].type === 'text'
+                ? result.content[0].text
+                : '';
+            throw new Error(`stub-LLM step "${label}" failed: ${text || 'tool error'}`);
+        }
+    }
+    return out;
+}
+export function youTubeTrendingJourney(tabId) {
+    return [
+        {
+            tool: 'browser_navigate',
+            args: { url: 'https://www.youtube.com/', tabId },
+            label: 'navigate to youtube.com',
+        },
+        {
+            tool: 'browser_snapshot',
+            args: { tabId },
+            label: 'snapshot home page to locate Trending link',
+        },
+        {
+            tool: 'browser_click',
+            args: { tabId, ref: 'e10' },
+            label: 'click Trending nav link',
+        },
+        {
+            tool: 'browser_snapshot',
+            args: { tabId },
+            label: 'snapshot trending page',
+        },
+    ];
+}
+export async function spawnPmPlanAgents(harness, planId, specs) {
+    const handles = [];
+    for (const spec of specs) {
+        const agent = harness.spawnAgent({ agentId: spec.agentId, planId });
+        const tabId = await agent.openTab(spec.url);
+        await agent.leases.ensure(tabId);
+        const nav = await agent.runTool('browser_navigate', {
+            url: spec.url,
+            tabId,
+        });
+        if (nav.isError) {
+            const text = nav.content[0] && nav.content[0].type === 'text'
+                ? nav.content[0].text
+                : 'unknown';
+            throw new Error(`spawnPmPlanAgents: navigate failed for ${spec.agentId}: ${text}`);
+        }
+        handles.push({ spec, agent, tabId });
+    }
+    return handles;
+}
+export async function summarizeAgentTabState(host, planId) {
+    const leases = await host.listLeases({ planId });
+    const byAgent = new Map();
+    const allTabIds = [];
+    for (const lease of leases) {
+        const tabs = byAgent.get(lease.agentId) ?? [];
+        tabs.push(lease.tabId);
+        byAgent.set(lease.agentId, tabs);
+        allTabIds.push(lease.tabId);
+    }
+    return { byAgent, allTabIds };
+}
+export const PM_PLAN_OPS = [
+    'tab_select',
+    'snapshot',
+    'navigate',
+    'screenshot',
+];
+export async function randomPmPlanStep(agent, tabId, url, rng) {
+    const weighted = [
+        'tab_select',
+        'tab_select',
+        'snapshot',
+        'navigate',
+        'screenshot',
+    ];
+    const op = weighted[Math.floor(rng() * weighted.length)] ?? 'tab_select';
+    let result;
+    switch (op) {
+        case 'tab_select':
+            result = await agent.runTool('browser_tab_select', { tabId });
+            break;
+        case 'snapshot':
+            result = await agent.runTool('browser_snapshot', { tabId });
+            break;
+        case 'navigate':
+            result = await agent.runTool('browser_navigate', { url, tabId });
+            break;
+        case 'screenshot':
+            result = await agent.runTool('browser_take_screenshot', { tabId });
+            break;
+    }
+    return { op, result };
+}

package/dist/server/routes/files.js

@@ -0,0 +1,18 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { Hono } from 'hono';
+export function createFileRoutes(fileService) {
+    const routes = new Hono();
+    routes.get('/', (c) => {
+        try {
+            const filter = c.req.query('filter') || '';
+            const baseDir = (c.req.query('baseDir') || 'scores');
+            const files = fileService.getAllFiles(baseDir, filter);
+            return c.json({ files });
+        }
+        catch (error) {
+            return c.json({ error: error.message }, 500);
+        }
+    });
+    return routes;
+}

package/dist/server/routes/improvise.js

@@ -0,0 +1,64 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { join } from 'node:path';
+import { Hono } from 'hono';
+import { spacePath } from '../services/space-layout.js';
+export function createImproviseRoutes(workingDir) {
+    const routes = new Hono();
+    routes.get('/sessions', async (c) => {
+        try {
+            const sessionsDir = spacePath(workingDir, 'history');
+            const { readdirSync, existsSync, readFileSync } = await import('node:fs');
+            if (!existsSync(sessionsDir)) {
+                return c.json({ sessions: [] });
+            }
+            const historyFiles = readdirSync(sessionsDir)
+                .filter((name) => name.endsWith('.json'))
+                .sort((a, b) => {
+                const timestampA = parseInt(a.replace('.json', ''), 10);
+                const timestampB = parseInt(b.replace('.json', ''), 10);
+                return timestampB - timestampA;
+            });
+            const sessions = historyFiles.map((filename) => {
+                const historyPath = join(sessionsDir, filename);
+                try {
+                    const historyData = JSON.parse(readFileSync(historyPath, 'utf-8'));
+                    const firstPrompt = historyData.movements?.[0]?.userPrompt || '';
+                    return {
+                        sessionId: historyData.sessionId,
+                        startedAt: historyData.startedAt,
+                        lastActivityAt: historyData.lastActivityAt,
+                        totalTokens: historyData.totalTokens,
+                        movementCount: historyData.movements?.length || 0,
+                        title: firstPrompt.slice(0, 80) + (firstPrompt.length > 80 ? '...' : ''),
+                        movements: historyData.movements || []
+                    };
+                }
+                catch {
+                    return null;
+                }
+            }).filter(Boolean);
+            return c.json({ sessions });
+        }
+        catch (error) {
+            return c.json({ error: error.message }, 500);
+        }
+    });
+    routes.get('/sessions/:sessionId', async (c) => {
+        try {
+            const { sessionId } = c.req.param();
+            const timestamp = sessionId.replace('improv-', '');
+            const historyPath = spacePath(workingDir, 'history', `${timestamp}.json`);
+            const { existsSync, readFileSync } = await import('node:fs');
+            if (!existsSync(historyPath)) {
+                return c.json({ error: 'Session not found' }, 404);
+            }
+            const historyData = JSON.parse(readFileSync(historyPath, 'utf-8'));
+            return c.json(historyData);
+        }
+        catch (error) {
+            return c.json({ error: error.message }, 500);
+        }
+    });
+    return routes;
+}

package/dist/server/routes/index.js

@@ -0,0 +1,7 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export { createFileRoutes } from './files.js';
+export { createImproviseRoutes } from './improvise.js';
+export { createInstanceRoutes, createShutdownRoute } from './instances.js';
+export { createInternalRoutes } from './internal.js';
+export { createNotificationRoutes } from './notifications.js';

package/dist/server/routes/instances.js

@@ -0,0 +1,41 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { Hono } from 'hono';
+import { getClientId } from '../services/client-id.js';
+import { InstanceRegistry } from '../services/instances.js';
+export function createInstanceRoutes(instanceRegistry) {
+    const routes = new Hono();
+    routes.get('/', (c) => {
+        try {
+            const instances = InstanceRegistry.getAllInstances();
+            return c.json({ instances });
+        }
+        catch (error) {
+            return c.json({ error: error.message }, 500);
+        }
+    });
+    routes.get('/current', (c) => {
+        try {
+            const instance = instanceRegistry.getCurrentInstance();
+            return c.json({
+                instance,
+                clientId: getClientId()
+            });
+        }
+        catch (error) {
+            return c.json({ error: error.message }, 500);
+        }
+    });
+    return routes;
+}
+export function createShutdownRoute(instanceRegistry) {
+    const routes = new Hono();
+    routes.post('/', (c) => {
+        setTimeout(() => {
+            instanceRegistry.unregister();
+            process.exit(0);
+        }, 100);
+        return c.json({ success: true, message: 'Shutting down...' });
+    });
+    return routes;
+}