@minionry/minion 0.7.36

package/dist/server/engines/claude/ClaudeCodeEngine.js

@@ -0,0 +1,316 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { executeClaudeCommand } from '../../cli/headless/claude-invoker.js';
+import { killProcessGroup } from '../../cli/headless/runner.js';
+import { EngineEventStream } from '../engine-event-stream.js';
+import { resolveClaudeCommand } from './claude-command.js';
+export class ClaudeCodeEngine extends EngineEventStream {
+    engineId = 'claude-code';
+    sessionOptions = null;
+    claudeSessionId;
+    runningProcesses = new Map();
+    currentRunPromise = null;
+    disposed = false;
+    usage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        lastUpdatedAt: Date.now(),
+    };
+    async startSession(options) {
+        if (this.sessionOptions) {
+            throw new Error('ClaudeCodeEngine: startSession called more than once');
+        }
+        if (this.disposed) {
+            throw new Error('ClaudeCodeEngine: cannot start a disposed engine');
+        }
+        this.sessionOptions = options;
+        this.claudeSessionId = options.resumeSessionId;
+        this.usage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            lastUpdatedAt: Date.now(),
+        };
+    }
+    async sendPrompt(prompt, attachments) {
+        if (!this.sessionOptions) {
+            throw new Error('ClaudeCodeEngine: sendPrompt called before startSession');
+        }
+        if (this.disposed) {
+            throw new Error('ClaudeCodeEngine: sendPrompt called after dispose');
+        }
+        if (this.currentRunPromise) {
+            throw new Error('ClaudeCodeEngine: another prompt is already in flight');
+        }
+        const opts = this.sessionOptions;
+        const imageAttachments = convertImageAttachments(attachments);
+        const toolStartTimes = new Map();
+        const toolNames = new Map();
+        const toolInputs = new Map();
+        const config = {
+            workingDir: opts.workingDir,
+            tokenBudgetThreshold: 170_000,
+            maxSessions: 50,
+            maxRetries: 3,
+            claudeCommand: resolveClaudeCommand(),
+            verbose: false,
+            noColor: false,
+            improvisationMode: false,
+            movementNumber: 0,
+            directPrompt: prompt,
+            promptContext: { accumulatedKnowledge: '', filesModified: [] },
+            stallWarningMs: 300_000,
+            stallKillMs: 1_800_000,
+            stallAssessEnabled: true,
+            stallMaxExtensions: 3,
+            stallHardCapMs: 3_600_000,
+            backgroundWaitGraceMs: 300_000,
+            backgroundWaitCapMs: 3_600_000,
+            backgroundWaitAbsoluteCapMs: 10_800_000,
+            firstEventDeadlineMs: 90_000,
+            enableToolWatchdog: true,
+            maxAutoRetries: 2,
+            model: opts.model,
+            effortLevel: opts.effortLevel,
+            fastMode: !!opts.fastMode,
+            ultracode: !!opts.ultracode,
+            appendSystemPrompt: opts.systemPrompt,
+            continueSession: !!this.claudeSessionId,
+            claudeSessionId: this.claudeSessionId,
+            imageAttachments,
+            disallowedTools: opts.disallowedTools,
+            inferenceOnly: false,
+            deployMode: opts.deployMode,
+            extraEnv: opts.extraEnv,
+            appTools: opts.appTools,
+            ...(opts.browserMcp
+                ? {
+                    browserMcp: {
+                        agentId: opts.browserMcp.agentId,
+                        agentLabel: opts.browserMcp.agentLabel,
+                        ...(opts.browserMcp.planId ? { planId: opts.browserMcp.planId } : {}),
+                        ...(opts.browserMcp.defaultTabId
+                            ? { defaultTabId: opts.browserMcp.defaultTabId }
+                            : {}),
+                        ...(opts.browserMcp.agentSessionId
+                            ? { agentSessionId: opts.browserMcp.agentSessionId }
+                            : {}),
+                    },
+                    agentId: opts.browserMcp.agentId,
+                    agentLabel: opts.browserMcp.agentLabel,
+                    minionryPort: opts.browserMcp.port,
+                    bouncerSecret: opts.browserMcp.bouncerSecret,
+                    ...(opts.browserMcp.planId ? { planId: opts.browserMcp.planId } : {}),
+                }
+                : {}),
+            outputCallback: (text) => {
+                this.emit({
+                    kind: 'message.delta',
+                    sessionId: this.sessionIdForEvent(),
+                    timestamp: Date.now(),
+                    text,
+                });
+            },
+            thinkingCallback: (text) => {
+                this.emit({
+                    kind: 'message.thinking',
+                    sessionId: this.sessionIdForEvent(),
+                    timestamp: Date.now(),
+                    text,
+                });
+            },
+            toolUseCallback: (event) => {
+                this.handleToolUseEvent(event, toolStartTimes, toolNames, toolInputs);
+            },
+            tokenUsageCallback: (usage) => {
+                this.usage = {
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    cacheCreationTokens: usage.cacheCreationTokens,
+                    cacheReadTokens: usage.cacheReadTokens,
+                    lastUpdatedAt: Date.now(),
+                };
+                this.emit({
+                    kind: 'usage.update',
+                    sessionId: this.sessionIdForEvent(),
+                    timestamp: Date.now(),
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    cacheCreationTokens: usage.cacheCreationTokens,
+                    cacheReadTokens: usage.cacheReadTokens,
+                });
+            },
+        };
+        const runPromise = executeClaudeCommand(prompt, 'engine', 1, {
+            config,
+            runningProcesses: this.runningProcesses,
+        });
+        this.currentRunPromise = runPromise;
+        runPromise.then((result) => this.onRunCompleted(result), (err) => this.onRunFailed(err));
+    }
+    async cancel() {
+        if (this.runningProcesses.size === 0 && !this.currentRunPromise)
+            return;
+        this.killAllRunningProcesses();
+        if (this.currentRunPromise) {
+            await this.currentRunPromise.catch(() => { });
+        }
+    }
+    getUsage() {
+        return { ...this.usage };
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.killAllRunningProcesses();
+        if (this.currentRunPromise) {
+            await this.currentRunPromise.catch(() => { });
+        }
+        this.closeIterator();
+    }
+    sessionIdForEvent() {
+        return this.claudeSessionId ?? 'pending';
+    }
+    killAllRunningProcesses() {
+        if (this.runningProcesses.size === 0)
+            return;
+        const pids = new Set();
+        for (const pid of this.runningProcesses.keys()) {
+            pids.add(pid);
+            killProcessGroup(pid, 'SIGTERM');
+        }
+        setTimeout(() => {
+            for (const [pid, proc] of this.runningProcesses) {
+                if (pids.has(pid) && !proc.killed) {
+                    killProcessGroup(pid, 'SIGKILL');
+                }
+            }
+        }, 5000).unref?.();
+    }
+    onRunCompleted(result) {
+        this.currentRunPromise = null;
+        if (result.claudeSessionId) {
+            this.claudeSessionId = result.claudeSessionId;
+        }
+        if (result.apiTokenUsage) {
+            const u = result.apiTokenUsage;
+            const cur = this.usage;
+            if (u.inputTokens > cur.inputTokens ||
+                u.outputTokens > cur.outputTokens ||
+                u.cacheCreationTokens > (cur.cacheCreationTokens ?? 0) ||
+                u.cacheReadTokens > (cur.cacheReadTokens ?? 0)) {
+                this.usage = {
+                    inputTokens: Math.max(u.inputTokens, cur.inputTokens),
+                    outputTokens: Math.max(u.outputTokens, cur.outputTokens),
+                    cacheCreationTokens: Math.max(u.cacheCreationTokens, cur.cacheCreationTokens ?? 0),
+                    cacheReadTokens: Math.max(u.cacheReadTokens, cur.cacheReadTokens ?? 0),
+                    lastUpdatedAt: Date.now(),
+                };
+            }
+        }
+        this.emit({
+            kind: 'session.idle',
+            sessionId: this.sessionIdForEvent(),
+            timestamp: Date.now(),
+            stopReason: result.stopReason,
+        });
+        if (result.exitCode !== 0 && !result.assistantResponse && !result.toolUseHistory?.length) {
+            const message = result.error || `Claude exited with code ${result.exitCode}`;
+            this.emit({
+                kind: 'engine.error',
+                sessionId: this.sessionIdForEvent(),
+                timestamp: Date.now(),
+                code: 'CLAUDE_RUN_ERROR',
+                message,
+                fatal: false,
+            });
+        }
+    }
+    onRunFailed(err) {
+        this.currentRunPromise = null;
+        const message = err instanceof Error ? err.message : String(err);
+        this.emit({
+            kind: 'engine.error',
+            sessionId: this.sessionIdForEvent(),
+            timestamp: Date.now(),
+            code: 'CLAUDE_SPAWN_ERROR',
+            message,
+            fatal: true,
+        });
+    }
+    handleToolUseEvent(event, starts, names, inputs) {
+        if (!event.toolId)
+            return;
+        if (event.type === 'tool_start') {
+            this.onToolStart(event, starts, names);
+        }
+        else if (event.type === 'tool_complete') {
+            this.onToolComplete(event, names, inputs);
+        }
+        else if (event.type === 'tool_result') {
+            this.onToolResult(event, starts, names, inputs);
+        }
+    }
+    onToolStart(event, starts, names) {
+        const ts = Date.now();
+        const toolId = event.toolId;
+        starts.set(toolId, ts);
+        if (event.toolName)
+            names.set(toolId, event.toolName);
+        this.emit({
+            kind: 'tool.start',
+            sessionId: this.sessionIdForEvent(),
+            timestamp: ts,
+            toolCallId: toolId,
+            toolName: event.toolName ?? '',
+            input: {},
+        });
+    }
+    onToolComplete(event, names, inputs) {
+        const toolId = event.toolId;
+        if (event.completeInput)
+            inputs.set(toolId, event.completeInput);
+        if (event.toolName)
+            names.set(toolId, event.toolName);
+    }
+    onToolResult(event, starts, names, inputs) {
+        const ts = Date.now();
+        const toolId = event.toolId;
+        const start = starts.get(toolId) ?? ts;
+        this.emit({
+            kind: 'tool.end',
+            sessionId: this.sessionIdForEvent(),
+            timestamp: ts,
+            toolCallId: toolId,
+            toolName: names.get(toolId) ?? '',
+            input: inputs.get(toolId) ?? {},
+            result: event.result ?? '',
+            isError: event.isError ?? false,
+            durationMs: ts - start,
+        });
+        starts.delete(toolId);
+        names.delete(toolId);
+        inputs.delete(toolId);
+    }
+}
+function convertImageAttachments(attachments) {
+    if (!attachments || attachments.length === 0)
+        return undefined;
+    const images = [];
+    for (const a of attachments) {
+        if (!a.isImage || !a.base64Content)
+            continue;
+        images.push({
+            fileName: a.fileName,
+            filePath: a.filePath ?? a.fileName,
+            content: a.base64Content,
+            isImage: true,
+            mimeType: a.mimeType,
+        });
+    }
+    return images.length > 0 ? images : undefined;
+}

package/dist/server/engines/claude/claude-command.js

@@ -0,0 +1,32 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { accessSync, constants, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+const CLAUDE_EXE = process.platform === 'win32' ? 'claude.exe' : 'claude';
+function installLocations(home) {
+    const locations = [join(home, '.local', 'bin', CLAUDE_EXE), join(home, '.claude', 'local', CLAUDE_EXE)];
+    if (process.platform !== 'win32')
+        locations.push('/opt/homebrew/bin/claude', '/usr/local/bin/claude');
+    return locations;
+}
+function isExecutableFile(path) {
+    try {
+        if (!statSync(path).isFile())
+            return false;
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveClaudeCommand({ env = process.env, home = homedir(), isExecutable = isExecutableFile, } = {}) {
+    const override = env.CLAUDE_COMMAND?.trim();
+    if (override)
+        return override;
+    const pathDirs = (env.PATH ?? '').split(delimiter).filter((dir) => dir.length > 0);
+    if (pathDirs.some((dir) => isExecutable(join(dir, CLAUDE_EXE))))
+        return 'claude';
+    return installLocations(home).find(isExecutable) ?? 'claude';
+}