@minionry/minion 0.7.36

package/dist/server/routes/notifications.js

@@ -0,0 +1,110 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Hono } from 'hono';
+import { resolveClaudeCommand } from '../engines/claude/claude-command.js';
+import { spacePath } from '../services/space-layout.js';
+export function createNotificationRoutes(workingDir) {
+    const routes = new Hono();
+    routes.post('/summarize', async (c) => {
+        try {
+            const body = await c.req.json();
+            const { prompt, output } = body;
+            if (!prompt || !output) {
+                return c.json({ error: 'Missing required fields: prompt and output' }, 400);
+            }
+            const summary = await generateNotificationSummary(prompt, output, workingDir);
+            return c.json({ summary });
+        }
+        catch (error) {
+            console.error('[Notifications] Error generating summary:', error);
+            return c.json({ summary: 'Task completed' });
+        }
+    });
+    return routes;
+}
+async function generateNotificationSummary(userPrompt, output, workingDir) {
+    return new Promise((resolve) => {
+        const tempDir = spacePath(workingDir, 'tmp');
+        if (!existsSync(tempDir)) {
+            mkdirSync(tempDir, { recursive: true });
+        }
+        let truncatedOutput = output;
+        if (output.length > 4000) {
+            const firstPart = output.slice(0, 2000);
+            const lastPart = output.slice(-1500);
+            truncatedOutput = `${firstPart}\n\n... [output truncated] ...\n\n${lastPart}`;
+        }
+        const summaryPrompt = `You are generating a SHORT browser notification summary for a completed task.
+The user ran a task and wants a brief notification to remind them what happened.
+
+USER'S ORIGINAL PROMPT:
+"${userPrompt}"
+
+TASK OUTPUT (may be truncated):
+${truncatedOutput}
+
+Generate a notification summary following these rules:
+1. Maximum 100 characters (this is a browser notification)
+2. Focus on the OUTCOME, not the process
+3. Be specific about what was accomplished
+4. Use past tense (e.g., "Fixed bug in auth.ts", "Added 3 new tests")
+5. If there was an error, mention it briefly
+6. No emojis, no markdown, just plain text
+
+Respond with ONLY the summary text, nothing else.`;
+        const promptFile = join(tempDir, `notif-summary-${Date.now()}.txt`);
+        writeFileSync(promptFile, summaryPrompt);
+        const systemPrompt = 'You are a notification summary assistant. Respond with only the summary text, no preamble or explanation.';
+        const args = [
+            '--print',
+            '--model', 'haiku',
+            '--system-prompt', systemPrompt,
+            promptFile
+        ];
+        const claude = spawn(resolveClaudeCommand(), args, {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        claude.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        claude.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        claude.on('close', (code) => {
+            try {
+                unlinkSync(promptFile);
+            }
+            catch {
+            }
+            if (code === 0 && stdout.trim()) {
+                const summary = stdout.trim().slice(0, 150);
+                resolve(summary);
+            }
+            else {
+                console.error('[Notifications] Claude error:', stderr || 'Unknown error');
+                resolve(createFallbackSummary(userPrompt));
+            }
+        });
+        claude.on('error', (err) => {
+            console.error('[Notifications] Failed to spawn Claude:', err);
+            resolve(createFallbackSummary(userPrompt));
+        });
+        setTimeout(() => {
+            claude.kill();
+            resolve(createFallbackSummary(userPrompt));
+        }, 10000);
+    });
+}
+function createFallbackSummary(userPrompt) {
+    const truncated = userPrompt.slice(0, 60);
+    if (userPrompt.length > 60) {
+        return `Completed: "${truncated}..."`;
+    }
+    return `Completed: "${truncated}"`;
+}

package/dist/server/server-setup.js

@@ -0,0 +1,282 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { createAdaptorServer } from '@hono/node-server';
+import { getClientId } from './services/client-id.js';
+import { PlatformConnection } from './services/platform.js';
+import { resolveCliEnvironment, resolvePlatformUrl } from './services/platform-url.js';
+import { sdkGrantStateSnapshot, setPersistedGrantsListener } from './services/sdk/grant-store.js';
+import { captureException } from './services/sentry.js';
+import { makeSpaceKey } from './services/settings.js';
+import { getPTYManager } from './services/terminal/pty-manager.js';
+import { createFileTransferAgent } from './services/websocket/file-transfer-http.js';
+import { hasScopeBinding, resolveScopeDir } from './services/websocket/handler-context.js';
+import { restoreWorktreeFromRegistry } from './services/websocket/session-handlers.js';
+import { findAvailablePort } from './utils/port.js';
+export function setTerminalTitle(directory) {
+    const dirName = basename(directory) || directory;
+    const title = `minionry: ${dirName}`;
+    process.stdout.write(`\x1b]0;${title}\x07`);
+}
+export function ensureClaudeSettings(workingDir) {
+    const claudeDir = join(workingDir, '.claude');
+    const settingsPath = join(claudeDir, 'settings.json');
+    if (!existsSync(claudeDir)) {
+        mkdirSync(claudeDir, { recursive: true });
+    }
+    const recommendedSettings = {
+        env: {
+            CLAUDE_CODE_MAX_OUTPUT_TOKENS: "64000",
+            DISABLE_NONESSENTIAL_TRAFFIC: "1"
+        }
+    };
+    if (!existsSync(settingsPath)) {
+        writeFileSync(settingsPath, JSON.stringify(recommendedSettings, null, 2));
+        console.log(`📝 Created .claude/settings.json with recommended settings`);
+    }
+    else {
+        try {
+            const existingSettings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            let updated = false;
+            if (!existingSettings.env) {
+                existingSettings.env = {};
+                updated = true;
+            }
+            if (!existingSettings.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS) {
+                existingSettings.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = "64000";
+                updated = true;
+            }
+            if (!existingSettings.env.DISABLE_NONESSENTIAL_TRAFFIC) {
+                existingSettings.env.DISABLE_NONESSENTIAL_TRAFFIC = "1";
+                updated = true;
+            }
+            if (updated) {
+                writeFileSync(settingsPath, JSON.stringify(existingSettings, null, 2));
+                console.log(`📝 Updated .claude/settings.json with recommended env settings`);
+            }
+        }
+        catch (_e) {
+            console.warn(`⚠️ Could not parse existing .claude/settings.json, skipping update`);
+        }
+    }
+}
+export async function listenWithPortFallback(opts) {
+    const { app, preferredPort, maxScan = 20 } = opts;
+    const listenOnce = (port) => new Promise((resolve, reject) => {
+        const server = createAdaptorServer({ fetch: app.fetch });
+        const onError = (err) => {
+            server.removeListener('error', onError);
+            reject(err);
+        };
+        server.once('error', onError);
+        server.listen(port, () => {
+            server.removeListener('error', onError);
+            const address = server.address();
+            const boundPort = typeof address === 'object' && address ? address.port : port;
+            resolve({ server, port: boundPort });
+        });
+    });
+    const candidate = await findAvailablePort(preferredPort, maxScan);
+    try {
+        return await listenOnce(candidate);
+    }
+    catch (err) {
+        if (err.code !== 'EADDRINUSE') {
+            throw err;
+        }
+        return await listenOnce(0);
+    }
+}
+export function wrapWebSocket(ws, workingDir) {
+    return {
+        send: (data) => ws.send(data),
+        close: () => ws.close(),
+        get readyState() { return ws.readyState; },
+        _workingDir: workingDir,
+        _ws: ws
+    };
+}
+export function createPlatformRelayContext(platformSend, workingDir, getBufferedAmount = () => 0) {
+    return {
+        send: (data) => {
+            try {
+                const response = typeof data === 'string' ? JSON.parse(data) : JSON.parse(data.toString());
+                platformSend(response);
+            }
+            catch (e) {
+                console.error('[PlatformRelay] Failed to parse response:', e);
+            }
+        },
+        close: () => {
+        },
+        readyState: 1,
+        _workingDir: workingDir,
+        _isPlatformRelay: true,
+        _getBufferedAmount: getBufferedAmount
+    };
+}
+function sanitizeLocalMessage(raw) {
+    const message = typeof raw === 'string' ? raw : raw.toString('utf-8');
+    if (!message.includes('_role'))
+        return message;
+    try {
+        const parsed = JSON.parse(message);
+        if ('_role' in parsed) {
+            delete parsed._role;
+            return JSON.stringify(parsed);
+        }
+    }
+    catch {   }
+    return message;
+}
+export function attachLocalWebSocketRouting(opts) {
+    const { wss, port, workingDir, authService, wsHandler } = opts;
+    wss.on('connection', (ws, req) => {
+        const url = new URL(req.url || '/', `http://localhost:${port}`);
+        if (url.pathname !== '/ws') {
+            ws.close(1008, 'Invalid WebSocket path');
+            return;
+        }
+        const wsToken = url.searchParams.get('token');
+        if (!wsToken || !authService.validateLocalToken(wsToken)) {
+            ws.close(4001, 'Unauthorized');
+            return;
+        }
+        const wrappedWs = wrapWebSocket(ws, workingDir);
+        wsHandler.handleConnection(wrappedWs, workingDir);
+        ws.on('message', (data) => {
+            wsHandler.handleMessage(wrappedWs, sanitizeLocalMessage(data), workingDir);
+        });
+        ws.on('close', () => wsHandler.handleClose(wrappedWs));
+        ws.on('error', (error) => {
+            console.error('[WebSocket] Error:', error);
+            captureException(error, { context: 'websocket.connection' });
+        });
+    });
+}
+export function resolveAppUrl() {
+    if (process.env.APP_ORIGIN)
+        return process.env.APP_ORIGIN;
+    const platformUrl = resolvePlatformUrl();
+    if (platformUrl.includes('localhost') || platformUrl.includes('127.0.0.1')) {
+        return 'http://localhost:4100';
+    }
+    return platformUrl.replace('//api.', '//app.');
+}
+export function formatConnectedBanner(opts) {
+    const { environment, appUrl, relayUrl } = opts;
+    if (environment === 'production') {
+        return [`Connected: ${appUrl}`];
+    }
+    return [
+        `Connected: ${appUrl}  [environment: ${environment} · relay: ${relayUrl}]`,
+        `⚠ This machine is tagged "${environment}", so it appears only in ${environment} views —`,
+        `  NOT on the production app. To make it show on production, run plain \`minion\``,
+        `  with no environment flag and with MINIONRY_ENV unset.`,
+    ];
+}
+export function createPlatformRelay(workingDir, wsHandler, hooks = {}) {
+    let platformRelayContext = null;
+    let pendingRelayMessages = [];
+    const fileTransferAgent = createFileTransferAgent({
+        platformUrl: resolvePlatformUrl(),
+        workingDir,
+        resolveEffectiveDir: (tabId) => {
+            if (!tabId)
+                return workingDir;
+            if (!hasScopeBinding(wsHandler, tabId)) {
+                restoreWorktreeFromRegistry(wsHandler, wsHandler.getRegistry(workingDir), tabId);
+            }
+            return resolveScopeDir(wsHandler, tabId, workingDir);
+        },
+        broadcast: (response) => wsHandler.broadcastToAll(response),
+    });
+    const pushGrantSnapshot = () => {
+        try {
+            platformConnection.send({
+                type: 'sdkGrantState',
+                data: sdkGrantStateSnapshot(makeSpaceKey(getClientId(), workingDir)),
+            });
+        }
+        catch (err) {
+            console.warn('[Platform] Failed to push the sdkGrantState snapshot:', err);
+        }
+    };
+    const platformConnection = new PlatformConnection(workingDir, {
+        onConnected: () => {
+            for (const line of formatConnectedBanner({
+                environment: resolveCliEnvironment(),
+                appUrl: resolveAppUrl(),
+                relayUrl: resolvePlatformUrl(),
+            })) {
+                console.log(line);
+            }
+            pushGrantSnapshot();
+            wsHandler.setUsageReporter((report) => {
+                platformConnection.send({ type: 'reportUsage', data: report });
+            });
+        },
+        onDisconnected: () => {
+            if (platformRelayContext) {
+                wsHandler.handleTransportDetach(platformRelayContext);
+                platformRelayContext = null;
+            }
+            pendingRelayMessages = [];
+        },
+        onWebConnected: () => {
+            if (platformRelayContext) {
+                wsHandler.handleTransportDetach(platformRelayContext);
+            }
+            platformRelayContext = createPlatformRelayContext((message) => platformConnection.send(message), workingDir, () => platformConnection.getOutboundBufferedAmount());
+            wsHandler.handleConnection(platformRelayContext, workingDir);
+            if (pendingRelayMessages.length > 0) {
+                for (const message of pendingRelayMessages) {
+                    wsHandler.handleMessage(platformRelayContext, JSON.stringify(message), workingDir);
+                }
+                pendingRelayMessages = [];
+            }
+        },
+        onWebDisconnected: () => {
+            if (platformRelayContext) {
+                wsHandler.handleClose(platformRelayContext);
+                platformRelayContext = null;
+            }
+            pendingRelayMessages = [];
+        },
+        onViewerDisconnected: (viewerId) => {
+            wsHandler.handleBrowserViewerDisconnected(viewerId);
+        },
+        onSuperseded: (info) => hooks.onSuperseded?.(info),
+        onRelayedMessage: (message) => {
+            if (platformRelayContext) {
+                wsHandler.handleMessage(platformRelayContext, JSON.stringify(message), workingDir);
+            }
+            else {
+                if (pendingRelayMessages.length < 100) {
+                    pendingRelayMessages.push(message);
+                }
+            }
+        },
+        onFileTransferRequest: (message) => {
+            fileTransferAgent.handleRequest(message);
+        }
+    });
+    platformConnection.connect();
+    setPersistedGrantsListener((spaceKey) => {
+        if (spaceKey === makeSpaceKey(getClientId(), workingDir))
+            pushGrantSnapshot();
+    });
+    getPTYManager().setE2eeActiveProvider(() => platformConnection.isSealingContent());
+    return platformConnection;
+}
+export function registerProcessErrorHandlers() {
+    process.on('uncaughtException', (err) => {
+        console.error('[Server] Uncaught exception:', err);
+        captureException(err, { context: 'uncaughtException' });
+    });
+    process.on('unhandledRejection', (reason) => {
+        console.error('[Server] Unhandled rejection:', reason);
+        captureException(reason instanceof Error ? reason : new Error(String(reason)), { context: 'unhandledRejection' });
+    });
+}

package/dist/server/services/agent-push.js

@@ -0,0 +1,148 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { basename } from 'node:path';
+import { getClientId } from './client-id.js';
+import { getCredentials } from './platform-credentials.js';
+import { resolvePlatformUrl } from './platform-url.js';
+import { makeSpaceKey } from './settings.js';
+const APP_ID = 'minionry:agents';
+const BODY_BY_EVENT = {
+    task_complete: 'Task complete',
+    task_failed: 'Task failed',
+    approval_needed: 'Approval needed',
+    question_waiting: 'Question waiting',
+};
+const THROTTLE_WINDOW_MS = 30_000;
+const NO_GRANT_BACKOFF_MS = 10 * 60 * 1000;
+const RATE_LIMIT_BACKOFF_MS = 60_000;
+const REQUEST_TIMEOUT_MS = 5_000;
+const defaultFetch = (url, init) => globalThis.fetch(url, init);
+function freshState() {
+    return {
+        disabledUntil: 0,
+        disabledForever: false,
+        loggedNoGrant: false,
+        logged401: false,
+        latchedToken: undefined,
+        lastSentAt: new Map(),
+        lastFailedMovement: new Map(),
+    };
+}
+let state = freshState();
+export function resetAgentPushForTests() {
+    state = freshState();
+}
+function debugLog(message) {
+    console.debug(`[agent-push] ${message}`);
+}
+function throttleKey(params) {
+    return `${params.tabId}:${params.event}`;
+}
+function isThrottled(params) {
+    const last = state.lastSentAt.get(throttleKey(params));
+    return last !== undefined && Date.now() - last < THROTTLE_WINDOW_MS;
+}
+function isSuppressedCompletion(params) {
+    if (params.event !== 'task_complete' || params.movementKey === undefined)
+        return false;
+    return state.lastFailedMovement.get(params.tabId) === params.movementKey;
+}
+function buildPayload(params) {
+    const spaceName = basename(params.workingDirectory) || params.workingDirectory;
+    const stableKey = makeSpaceKey(getClientId(), params.workingDirectory);
+    return {
+        appId: APP_ID,
+        notification: {
+            title: spaceName,
+            body: BODY_BY_EVENT[params.event],
+            url: `/?space=${encodeURIComponent(stableKey)}&tab=${encodeURIComponent(params.tabId)}`,
+            tag: `agents:${params.tabId}`,
+        },
+    };
+}
+async function requestOnce(fetchImpl, url, token, payload) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        return await fetchImpl(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+            signal: controller.signal,
+        });
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function requestWithRetry(fetchImpl, url, token, payload) {
+    const first = await requestOnce(fetchImpl, url, token, payload);
+    if (first)
+        return first;
+    return requestOnce(fetchImpl, url, token, payload);
+}
+function handleErrorResponse(response) {
+    if (response.status === 403) {
+        state.disabledUntil = Date.now() + NO_GRANT_BACKOFF_MS;
+        if (!state.loggedNoGrant) {
+            state.loggedNoGrant = true;
+            debugLog('no_grant — disabling Agents pushes for 10 minutes');
+        }
+        return;
+    }
+    if (response.status === 401) {
+        state.disabledForever = true;
+        if (!state.logged401) {
+            state.logged401 = true;
+            debugLog('401 — disabling Agents pushes until credentials change');
+        }
+        return;
+    }
+    if (response.status === 429) {
+        state.disabledUntil = Date.now() + RATE_LIMIT_BACKOFF_MS;
+    }
+}
+async function dispatch(params, options) {
+    const creds = getCredentials();
+    if (!creds?.token)
+        return;
+    if (state.latchedToken !== creds.token) {
+        state.latchedToken = creds.token;
+        state.disabledForever = false;
+        state.logged401 = false;
+    }
+    if (state.disabledForever)
+        return;
+    if (Date.now() < state.disabledUntil)
+        return;
+    const base = resolvePlatformUrl();
+    if (!base)
+        return;
+    if (isSuppressedCompletion(params))
+        return;
+    if (isThrottled(params))
+        return;
+    state.lastSentAt.set(throttleKey(params), Date.now());
+    const payload = buildPayload(params);
+    const fetchImpl = options.fetchImpl ?? defaultFetch;
+    const response = await requestWithRetry(fetchImpl, `${base}/api/notifications/push/self`, creds.token, payload);
+    if (!response)
+        return;
+    if (!response.ok) {
+        handleErrorResponse(response);
+        return;
+    }
+    if (params.event === 'task_failed' && params.movementKey !== undefined) {
+        state.lastFailedMovement.set(params.tabId, params.movementKey);
+    }
+}
+export function sendAgentPush(params, options = {}) {
+    void dispatch(params, options).catch(() => {
+    });
+}