@minionry/minion 0.7.36

package/dist/server/services/websocket/types.js

@@ -0,0 +1,96 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { AGENT_TAB_STATE_TYPES, BROWSER_BIDIRECTIONAL_TYPES, BROWSER_CLI_TO_WEB_TYPES, BROWSER_WEB_TO_CLI_TYPES, } from '@minionry/browser-types';
+import { isEngineId } from '../../engines/EngineEvent.js';
+const CoreMessages = ['execute', 'cancel', 'getHistory', 'getSessions', 'getSessionsCount', 'deleteSession', 'getSessionById', 'clearHistory', 'searchHistory', 'exportSession', 'importSession', 'new', 'autocomplete', 'readFile', 'ping', 'initTab', 'resumeSession', 'approve', 'reject', 'recordSelection', 'requestNotificationSummary', 'askUserQuestionResponse', 'queueEnqueuePrompt', 'queueRemovePrompt', 'queueClearPrompts', 'getTimeline'];
+const TerminalMessages = ['terminalInit', 'terminalReconnect', 'terminalList', 'terminalInput', 'terminalResize', 'terminalClose'];
+const FileExplorerMessages = ['listDirectory', 'writeFile', 'createFile', 'createDirectory', 'deleteFile', 'renameFile', 'notifyFileOpened', 'searchFileContents', 'cancelSearch', 'findDefinition'];
+export const CollabMessages = ['collabJoin', 'collabLeave', 'collabPush', 'collabCursor', 'collabFlush'];
+export const GitMessages = ['gitStatus', 'gitStage', 'gitUnstage', 'gitCommit', 'gitCommitWithAI', 'gitPush', 'gitPull', 'gitLog', 'gitDiscoverRepos', 'gitSetDirectory', 'gitGetRemoteInfo', 'gitCreatePR', 'gitGeneratePRDescription'];
+export const GitBranchMessages = ['gitListBranches', 'gitCheckout', 'gitCreateBranch', 'gitDeleteBranch'];
+export const GitDiffMessages = ['gitDiff', 'gitShowCommit', 'gitCommitDiff'];
+export const GitTagMessages = ['gitListTags', 'gitCreateTag', 'gitPushTag'];
+export const GitWorktreeMessages = ['gitWorktreeList', 'gitWorktreeCreate', 'gitWorktreeCreateAndAssign', 'gitWorktreeRemove', 'tabWorktreeSwitch', 'tabRepoWorktreeSwitch', 'gitWorktreePush', 'gitWorktreeCreatePR'];
+export const GitMergeMessages = ['gitMergePreview', 'gitWorktreeMerge', 'gitMergeAbort', 'gitMergeComplete', 'gitMergeStashPop', 'gitMergeDiscardBlockers'];
+const SessionSyncMessages = ['getActiveTabs', 'createTab', 'reorderTabs', 'syncTabMeta', 'removeTab', 'markTabViewed', 'setTabEngine'];
+const SettingsMessages = ['getSettings', 'updateSettings', 'getModelCatalog'];
+const SystemPromptMessages = [
+    'getSystemPromptProfiles',
+    'createSystemPrompt',
+    'readSystemPrompt',
+    'saveSystemPrompt',
+    'deleteSystemPrompt',
+];
+const FileUploadMessages = ['fileUploadStart', 'fileUploadChunk', 'fileUploadComplete', 'fileUploadCancel'];
+const FileDownloadMessages = ['fileDownloadStart', 'fileDownloadCancel'];
+export const FileShareMessages = ['fileShareListDirectory', 'fileShareReadFile', 'fileShareDownloadStart', 'fileShareDownloadCancel'];
+export const PlanMessages = ['planInit', 'planGetState', 'planListIssues', 'planGetIssue', 'planGetSprint', 'planGetMilestone', 'planUpdateIssue', 'planDeleteIssue', 'planScaffold', 'planPrompt', 'planExecute', 'planExecuteEpic', 'planPause', 'planStop', 'planResume', 'queueEnqueueComposerPrompt', 'queueRemoveComposerPrompt', 'queueClearComposerPrompts', 'getPmTimeline'];
+export const PlanBoardMessages = ['planCreateBoard', 'planUpdateBoard', 'planArchiveBoard', 'planRestoreBoard', 'planGetBoard', 'planGetBoardState', 'planReorderBoards', 'planSetActiveBoard', 'planGetBoardArtifacts', 'planExportBoard', 'planImportBoard', 'planDownloadBoard', 'planInstantiateTemplate'];
+export const PlanSprintMessages = ['planCreateSprint', 'planActivateSprint', 'planCompleteSprint', 'planGetSprintArtifacts'];
+export const PlanScheduleMessages = ['planScheduleCreate', 'planScheduleUpdate', 'planScheduleDelete', 'planScheduleList', 'planScheduleValidateSource'];
+export const AgentScheduleMessages = ['agentScheduleCreate', 'agentScheduleUpdate', 'agentScheduleDelete', 'agentScheduleList'];
+const SkillMessages = ['listSkills', 'chatToBoard'];
+const SnippetMessages = ['snippetAutocomplete', 'snippetList', 'snippetCreate', 'snippetGet', 'snippetUpdate'];
+export const InstanceMessages = ['shutdownInstance', 'restartInstance'];
+export const SdkMessages = ['sdkConnect', 'sdkRequest', 'sdkAgentRun', 'sdkPmWrite', 'sdkPmExecute', 'sdkPmSchedule', 'sdkFilesWrite', 'sdkStorageWrite', 'sdkCancel', 'sdkRevoke', 'sdkAgentSession', 'sdkAgentInteract', 'sdkGitWrite', 'sdkTerminalWrite', 'sdkToolsServe', 'sdkQualityWrite', 'sdkBrowserWrite', 'sdkConsentDecision', 'sdkInferenceRun', 'sdkEndpointsWrite'];
+export const AppsMessages = ['appInstallLocal', 'appServeStatus', 'appStop', 'appUpdate', 'appGreenlightDecision', 'appSpaceList', 'appSpaceAdd', 'appSpaceRemove', 'appSpaceConfigure'];
+export const EngineAuthMessages = [
+    'engineAuthStatus',
+    'setEngineApiKey',
+    'removeEngineApiKey',
+    'startEngineLogin',
+    'testEngineCredential',
+    'engineModelProfiles',
+    'setEngineModelProfile',
+    'removeEngineModelProfile',
+];
+const BrowserBridgeMessages = [...BROWSER_WEB_TO_CLI_TYPES, ...BROWSER_BIDIRECTIONAL_TYPES];
+export { isEngineId };
+export const DEFAULT_ENGINE_ID = 'claude-code';
+export function normalizeEngineId(value) {
+    return isEngineId(value) ? value : DEFAULT_ENGINE_ID;
+}
+const CoreResponseMessages = ['output', 'thinking', 'movementStart', 'movementComplete', 'movementError', 'sessionUpdate', 'history', 'sessions', 'sessionsCount', 'sessionDeleted', 'sessionData', 'historyCleared', 'searchResults', 'newSession', 'autocomplete', 'fileContent', 'error', 'pong', 'tabInitialized', 'approvalRequired', 'toolUse', 'streamingTokens', 'executionTargetUpdate', 'notificationSummary', 'executeAck', 'clientOffline', 'clientAuthExpired', 'askUserQuestion', 'askUserQuestionDismissed', 'askUserQuestionAutoAnswered', 'timelineSnapshot', 'timelineEvent', 'timelinePage', 'sessionExported', 'sessionImported'];
+const TerminalResponseMessages = ['terminalOutput', 'terminalReady', 'terminalExit', 'terminalError', 'terminalList', 'terminalScrollback', 'terminalCreated', 'terminalClosed'];
+const FileExplorerResponseMessages = ['directoryListing', 'fileWritten', 'fileCreated', 'directoryCreated', 'fileDeleted', 'fileRenamed', 'fileOpened', 'fileContentChanged', 'contentSearchResults', 'contentSearchComplete', 'contentSearchError', 'definitionResult', 'fileError'];
+export const CollabResponseMessages = ['collabJoined', 'collabUpdate', 'collabCursor', 'collabRoster', 'collabSaved', 'collabPushRejected', 'collabEnded', 'collabError'];
+export const GitResponseMessages = ['gitStatus', 'gitStaged', 'gitUnstaged', 'gitCommitted', 'gitCommitMessage', 'gitCommitSuggestion', 'gitPushed', 'gitPulled', 'gitLog', 'gitError', 'gitReposDiscovered', 'gitDirectorySet', 'gitRemoteInfo', 'gitPRCreated', 'gitPRDescription'];
+export const GitBranchResponseMessages = ['gitBranchList', 'gitCheckedOut', 'gitBranchCreated', 'gitBranchDeleted'];
+export const GitDiffResponseMessages = ['gitDiffResult', 'gitCommitDetail', 'gitCommitDiffResult'];
+export const GitTagResponseMessages = ['gitTagList', 'gitTagCreated', 'gitTagPushed'];
+export const GitWorktreeResponseMessages = ['gitWorktreeListResult', 'gitWorktreeCreated', 'gitWorktreeCreatedAndAssigned', 'gitWorktreeRemoved', 'tabWorktreeSwitched', 'tabRepoWorktreesSwitched', 'gitBranchChanged', 'gitWorktreePushed', 'gitWorktreePRCreated'];
+export const GitMergeResponseMessages = ['gitMergePreviewResult', 'gitWorktreeMergeResult', 'gitMergeAborted', 'gitMergeCompleted', 'gitMergeStashPopped', 'gitMergeBlockersDiscarded'];
+const SessionSyncResponseMessages = ['activeTabs', 'tabCreated', 'tabRemoved', 'tabRenamed', 'tabsReordered', 'promptTextSync', 'tabViewed', 'tabStateChanged', 'tabEngineOverride', 'tabNotFound', 'promptQueueSync'];
+const SettingsResponseMessages = ['settings', 'settingsUpdated', 'bouncerClassifierHealth', 'modelCatalog'];
+const SystemPromptResponseMessages = [
+    'systemPromptProfiles',
+    'systemPromptCreated',
+    'systemPromptContent',
+    'systemPromptSaved',
+    'systemPromptDeleted',
+];
+const FileUploadResponseMessages = ['fileUploadAck', 'fileUploadReady', 'fileUploadError'];
+const FileDownloadResponseMessages = ['fileDownloadReady', 'fileDownloadChunk', 'fileDownloadComplete', 'fileDownloadError'];
+const FileShareResponseMessages = ['fileShareDirectoryListing', 'fileShareFileContent', 'fileShareError', 'fileShareDownloadReady', 'fileShareDownloadChunk', 'fileShareDownloadComplete', 'fileShareDownloadError'];
+export const PlanResponseMessages = ['planState', 'planIssueList', 'planIssue', 'planSprint', 'planMilestone', 'planNotFound', 'planStateUpdated', 'planIssueUpdated', 'planIssueDeleted', 'planScaffolded', 'planPromptStreaming', 'planPromptToolUse', 'planPromptProgress', 'planPromptTokens', 'planPromptResponse', 'planExecutionStarted', 'planExecutionProgress', 'planExecutionOutput', 'planExecutionPrompt', 'planExecutionToolUse', 'planExecutionTokens', 'planExecutionMetrics', 'planExecutionComplete', 'planExecutionError', 'planError', 'composerPromptQueueSync', 'pmTimelineSnapshot', 'pmTimelineEvent'];
+const PlanBoardResponseMessages = ['planBoardCreated', 'planBoardUpdated', 'planBoardArchived', 'planBoardState', 'planBoardArtifacts', 'planWorkspaceUpdated', 'planBoardExported', 'planBoardImported', 'planBoardDownloaded', 'planTemplateInstantiated'];
+const PlanSprintResponseMessages = ['planSprintCreated', 'planSprintUpdated', 'planSprintCompleted', 'planSprintArtifacts', 'planReviewProgress'];
+const PlanScheduleResponseMessages = ['planScheduleCreated', 'planScheduleUpdated', 'planScheduleDeleted', 'planScheduleListResult', 'planScheduleValidateSourceResult', 'planSchedulesChanged', 'planScheduleFired'];
+export const AgentScheduleResponseMessages = ['agentScheduleCreated', 'agentScheduleUpdated', 'agentScheduleDeleted', 'agentScheduleListResult', 'agentSchedulesChanged', 'agentScheduleFired'];
+const SkillResponseMessages = ['skillsList', 'chatToBoardCreated'];
+const SnippetResponseMessages = ['snippetSuggestions', 'snippetListResult', 'snippetExpansion', 'snippetCreateResult', 'snippetGetResult', 'snippetUpdateResult'];
+const InstanceResponseMessages = ['shuttingDown'];
+const SdkResponseMessages = ['sdkConnectResult', 'sdkResponse', 'sdkEvent', 'sdkGrantsChanged', 'sdkConsentRequest', 'sdkToolCall'];
+export const AppsResponseMessages = ['appServeStatus', 'appBuildLog', 'appGreenlightRequest', 'appError', 'appSpaceList'];
+export const EngineAuthResponseMessages = [
+    'engineAuthStatusResult',
+    'engineLoginProgress',
+    'engineAuthError',
+    'engineCredentialTestResult',
+    'engineModelProfilesResult',
+];
+const BrowserBridgeResponseMessages = [
+    ...BROWSER_CLI_TO_WEB_TYPES,
+    ...BROWSER_BIDIRECTIONAL_TYPES,
+    ...AGENT_TAB_STATE_TYPES,
+];

package/dist/server/types/company-messages.js

@@ -0,0 +1,102 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const CompanyInboundMessages = [
+    'companyExecuteBoard',
+    'companyPauseExecution',
+    'companyResumeExecution',
+    'companyStopExecution',
+    'companyGetExecutionStatus',
+    'companyEmergencyStop',
+];
+export const CompanyExecutionResponseMessages = [
+    'companyExecutionStarted',
+    'companyExecutionProgress',
+    'companyExecutionOutput',
+    'companyExecutionMetrics',
+    'companyExecutionComplete',
+    'companyExecutionError',
+    'companyBudgetWarning',
+    'companyBoardTriggered',
+];
+export const CompanyServerResponseMessages = [
+    'companyApprovalCreated',
+    'companyApprovalResolved',
+    'companyStatusChanged',
+    'companyMetricRecorded',
+    'companyRevenueUpdate',
+    'companyBudgetUpdated',
+];
+export const CompanyErrorResponseMessages = ['companyError'];
+export const CompanyViewAllowedOperations = [
+    'companyGetExecutionStatus',
+];
+const INBOUND_SET = new Set(CompanyInboundMessages);
+const RESPONSE_SET = new Set([
+    ...CompanyExecutionResponseMessages,
+    ...CompanyServerResponseMessages,
+    ...CompanyErrorResponseMessages,
+]);
+export function isCompanyInboundMessageType(value) {
+    return typeof value === 'string' && INBOUND_SET.has(value);
+}
+export function isCompanyResponseMessageType(value) {
+    return typeof value === 'string' && RESPONSE_SET.has(value);
+}
+export function isCompanyMessageType(value) {
+    return isCompanyInboundMessageType(value) || isCompanyResponseMessageType(value);
+}
+export function isCompanyViewAllowed(type) {
+    return CompanyViewAllowedOperations.includes(type);
+}
+export function validateCompanyInboundData(type, 
+data) {
+    if (data == null || typeof data !== 'object') {
+        throw new Error(`${type}: data payload must be an object`);
+    }
+    if (type === 'companyExecuteBoard') {
+        const d = data;
+        requireString(type, 'companyId', d.companyId);
+        requireString(type, 'departmentId', d.departmentId);
+        requireString(type, 'departmentBoardId', d.departmentBoardId);
+        requireString(type, 'executionId', d.executionId);
+        requireString(type, 'trigger', d.trigger);
+        requireNumber(type, 'budgetRemainingCents', d.budgetRemainingCents);
+        requireString(type, 'riskTolerance', d.riskTolerance);
+        return;
+    }
+    if (type === 'companyEmergencyStop') {
+        requireString(type, 'companyId', data.companyId);
+        return;
+    }
+    requireString(type, 'executionId', data.executionId);
+}
+function requireString(type, field, value) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`${type}: "${field}" must be a non-empty string`);
+    }
+}
+function requireNumber(type, field, value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`${type}: "${field}" must be a finite number`);
+    }
+}
+function make(type, data, tabId) {
+    return tabId === undefined ? { type, data } : { type, tabId, data };
+}
+export const companyMessages = {
+    executionStarted: (data, tabId) => make('companyExecutionStarted', data, tabId),
+    executionProgress: (data, tabId) => make('companyExecutionProgress', data, tabId),
+    executionOutput: (data, tabId) => make('companyExecutionOutput', data, tabId),
+    executionMetrics: (data, tabId) => make('companyExecutionMetrics', data, tabId),
+    executionComplete: (data, tabId) => make('companyExecutionComplete', data, tabId),
+    executionError: (data, tabId) => make('companyExecutionError', data, tabId),
+    budgetWarning: (data, tabId) => make('companyBudgetWarning', data, tabId),
+    boardTriggered: (data, tabId) => make('companyBoardTriggered', data, tabId),
+    approvalCreated: (data, tabId) => make('companyApprovalCreated', data, tabId),
+    approvalResolved: (data, tabId) => make('companyApprovalResolved', data, tabId),
+    statusChanged: (data, tabId) => make('companyStatusChanged', data, tabId),
+    metricRecorded: (data, tabId) => make('companyMetricRecorded', data, tabId),
+    revenueUpdate: (data, tabId) => make('companyRevenueUpdate', data, tabId),
+    budgetUpdated: (data, tabId) => make('companyBudgetUpdated', data, tabId),
+    error: (data, tabId) => make('companyError', data, tabId),
+};

package/dist/server/utils/agent-manager.js

@@ -0,0 +1,202 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { MINIONRY_ROOT } from './paths.js';
+export class AgentManager {
+    bundledAgentsPath;
+    globalAgentsPath;
+    constructor() {
+        this.bundledAgentsPath = join(MINIONRY_ROOT, '.claude', 'agents');
+        this.globalAgentsPath = join(homedir(), '.claude', 'agents');
+    }
+    getProjectAgentsPath(workingDir) {
+        return join(workingDir, '.claude', 'agents');
+    }
+    listBundledAgents() {
+        if (!existsSync(this.bundledAgentsPath)) {
+            return [];
+        }
+        const files = readdirSync(this.bundledAgentsPath)
+            .filter(f => f.endsWith('.md') && f !== 'README.md');
+        return files.map(file => ({
+            name: basename(file, '.md'),
+            path: join(this.bundledAgentsPath, file),
+            location: 'bundled',
+            description: this.extractDescription(join(this.bundledAgentsPath, file))
+        }));
+    }
+    listGlobalAgents() {
+        if (!existsSync(this.globalAgentsPath)) {
+            return [];
+        }
+        const files = readdirSync(this.globalAgentsPath)
+            .filter(f => f.endsWith('.md'));
+        return files.map(file => ({
+            name: basename(file, '.md'),
+            path: join(this.globalAgentsPath, file),
+            location: 'global',
+            description: this.extractDescription(join(this.globalAgentsPath, file))
+        }));
+    }
+    listProjectAgents(workingDir) {
+        const projectPath = this.getProjectAgentsPath(workingDir);
+        if (!existsSync(projectPath)) {
+            return [];
+        }
+        const files = readdirSync(projectPath)
+            .filter(f => f.endsWith('.md'));
+        return files.map(file => ({
+            name: basename(file, '.md'),
+            path: join(projectPath, file),
+            location: 'project',
+            description: this.extractDescription(join(projectPath, file))
+        }));
+    }
+    extractDescription(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                if (!line.startsWith('#')) {
+                    return line.trim();
+                }
+            }
+        }
+        catch {
+        }
+        return undefined;
+    }
+    findAgent(agentName, workingDir) {
+        const agentFile = `${agentName}.md`;
+        if (workingDir) {
+            const projectPath = join(this.getProjectAgentsPath(workingDir), agentFile);
+            if (existsSync(projectPath)) {
+                return {
+                    name: agentName,
+                    path: projectPath,
+                    location: 'project',
+                    description: this.extractDescription(projectPath)
+                };
+            }
+        }
+        const globalPath = join(this.globalAgentsPath, agentFile);
+        if (existsSync(globalPath)) {
+            return {
+                name: agentName,
+                path: globalPath,
+                location: 'global',
+                description: this.extractDescription(globalPath)
+            };
+        }
+        const bundledPath = join(this.bundledAgentsPath, agentFile);
+        if (existsSync(bundledPath)) {
+            return {
+                name: agentName,
+                path: bundledPath,
+                location: 'bundled',
+                description: this.extractDescription(bundledPath)
+            };
+        }
+        return null;
+    }
+    async ensureAgentAvailable(agentName, workingDir) {
+        const agentFile = `${agentName}.md`;
+        const projectPath = join(this.getProjectAgentsPath(workingDir), agentFile);
+        const globalPath = join(this.globalAgentsPath, agentFile);
+        const bundledPath = join(this.bundledAgentsPath, agentFile);
+        if (existsSync(projectPath)) {
+            return {
+                name: agentName,
+                path: projectPath,
+                location: 'project',
+                description: this.extractDescription(projectPath)
+            };
+        }
+        if (existsSync(globalPath)) {
+            return {
+                name: agentName,
+                path: globalPath,
+                location: 'global',
+                description: this.extractDescription(globalPath)
+            };
+        }
+        if (!existsSync(bundledPath)) {
+            throw new Error(`Agent not found: ${agentName}\nNot available in bundled, global, or project agents.`);
+        }
+        const targetDir = dirname(projectPath);
+        mkdirSync(targetDir, { recursive: true });
+        copyFileSync(bundledPath, projectPath);
+        return {
+            name: agentName,
+            path: projectPath,
+            location: 'project',
+            description: this.extractDescription(projectPath)
+        };
+    }
+    installAgentGlobally(agentName) {
+        const agentFile = `${agentName}.md`;
+        const bundledPath = join(this.bundledAgentsPath, agentFile);
+        const globalPath = join(this.globalAgentsPath, agentFile);
+        if (!existsSync(bundledPath)) {
+            throw new Error(`Bundled agent not found: ${agentName}`);
+        }
+        mkdirSync(this.globalAgentsPath, { recursive: true });
+        copyFileSync(bundledPath, globalPath);
+    }
+    installAllAgentsGlobally() {
+        const bundled = this.listBundledAgents();
+        const installed = [];
+        mkdirSync(this.globalAgentsPath, { recursive: true });
+        for (const agent of bundled) {
+            const targetPath = join(this.globalAgentsPath, `${agent.name}.md`);
+            copyFileSync(agent.path, targetPath);
+            installed.push(agent.name);
+        }
+        return installed;
+    }
+    installAgentToProject(agentName, workingDir) {
+        const agentFile = `${agentName}.md`;
+        const bundledPath = join(this.bundledAgentsPath, agentFile);
+        const projectPath = join(this.getProjectAgentsPath(workingDir), agentFile);
+        if (!existsSync(bundledPath)) {
+            throw new Error(`Bundled agent not found: ${agentName}`);
+        }
+        const targetDir = dirname(projectPath);
+        mkdirSync(targetDir, { recursive: true });
+        copyFileSync(bundledPath, projectPath);
+    }
+    installAllAgentsToProject(workingDir) {
+        const bundled = this.listBundledAgents();
+        const installed = [];
+        const projectAgentsPath = this.getProjectAgentsPath(workingDir);
+        mkdirSync(projectAgentsPath, { recursive: true });
+        for (const agent of bundled) {
+            const targetPath = join(projectAgentsPath, `${agent.name}.md`);
+            copyFileSync(agent.path, targetPath);
+            installed.push(agent.name);
+        }
+        return installed;
+    }
+    extractAgentNamesFromScore(score) {
+        if (!Array.isArray(score.movements))
+            return [];
+        const names = score.movements
+            .flatMap(m => Array.isArray(m.musicians) ? m.musicians : [])
+            .filter(m => m.type === 'custom')
+            .map(m => m.config?.agent || m.role)
+            .filter(Boolean);
+        return [...new Set(names)];
+    }
+    async ensureScoreAgentsAvailable(score, workingDir) {
+        const agentNames = this.extractAgentNamesFromScore(score);
+        const results = new Map();
+        for (const agentName of agentNames) {
+            const info = await this.ensureAgentAvailable(agentName, workingDir);
+            results.set(agentName, info);
+        }
+        return results;
+    }
+}
+export const agentManager = new AgentManager();

package/dist/server/utils/console-timestamps.js

@@ -0,0 +1,24 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const ISO_PREFIX_RE = /^\[?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+const METHODS = ['log', 'info', 'warn', 'error', 'debug'];
+let installed = false;
+export function installConsoleTimestamps(instanceTag = String(process.pid)) {
+    if (installed)
+        return;
+    installed = true;
+    for (const method of METHODS) {
+        const original = console[method].bind(console);
+        console[method] = (...args) => {
+            const first = args[0];
+            if (typeof first === 'string' && ISO_PREFIX_RE.test(first)) {
+                original(...args);
+                return;
+            }
+            original(`[${new Date().toISOString()}] [${instanceTag}]`, ...args);
+        };
+    }
+}
+export function isConsoleTimestampsInstalled() {
+    return installed;
+}

package/dist/server/utils/file-store.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const DEFAULT_LOCK_TIMEOUT_MS = 5000;
+const DEFAULT_LOCK_STALE_MS = 2000;
+const RETRY_MIN_MS = 5;
+const RETRY_JITTER_MS = 20;
+const LOCK_OWNER_FILE = 'owner';
+let lockAcquisitionCounter = 0;
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function reclaimIfStale(lockPath, staleMs) {
+    try {
+        const before = readOwner(lockPath);
+        if (Date.now() - statSync(lockPath).mtimeMs <= staleMs)
+            return false;
+        if (readOwner(lockPath) !== before)
+            return false;
+        rmSync(lockPath, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function withFileLock(lockPath, fn, options = {}) {
+    const { timeoutMs = DEFAULT_LOCK_TIMEOUT_MS, staleMs = DEFAULT_LOCK_STALE_MS } = options;
+    const token = `${process.pid}:${lockAcquisitionCounter++}`;
+    const held = acquireLock(lockPath, token, timeoutMs, staleMs);
+    try {
+        return fn();
+    }
+    finally {
+        if (held && ownsLock(lockPath, token)) {
+            try {
+                rmSync(lockPath, { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
+    }
+}
+function acquireLock(lockPath, token, timeoutMs, staleMs) {
+    try {
+        mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 });
+    }
+    catch {
+    }
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const attempt = tryTakeLock(lockPath, token);
+        if (attempt === 'taken')
+            return true;
+        if (attempt === 'unavailable')
+            return false;
+        if (reclaimIfStale(lockPath, staleMs))
+            continue;
+        if (Date.now() >= deadline)
+            return false;
+        sleepSync(RETRY_MIN_MS + Math.floor(Math.random() * RETRY_JITTER_MS));
+    }
+}
+function tryTakeLock(lockPath, token) {
+    let created = false;
+    try {
+        mkdirSync(lockPath);
+        created = true;
+        writeFileSync(join(lockPath, LOCK_OWNER_FILE), token, { mode: 0o600 });
+        return 'taken';
+    }
+    catch (err) {
+        if (created) {
+            try {
+                rmSync(lockPath, { recursive: true, force: true });
+            }
+            catch {
+            }
+            return 'unavailable';
+        }
+        return err.code === 'EEXIST' ? 'contended' : 'unavailable';
+    }
+}
+function readOwner(lockPath) {
+    try {
+        return readFileSync(join(lockPath, LOCK_OWNER_FILE), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function ownsLock(lockPath, token) {
+    return readOwner(lockPath) === token;
+}
+export function writeFileAtomic(path, contents, options = {}) {
+    const { mode = 0o600 } = options;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tempPath = `${path}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tempPath, contents, { mode });
+        renameSync(tempPath, path);
+    }
+    catch (err) {
+        try {
+            rmSync(tempPath, { force: true });
+        }
+        catch {
+        }
+        throw err;
+    }
+}

package/dist/server/utils/paths.js

@@ -0,0 +1,28 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const IS_COMPILED = __filename.endsWith('.js');
+const SERVER_ROOT = resolve(__dirname, '..');
+export const MINIONRY_ROOT = resolve(SERVER_ROOT, IS_COMPILED ? '../..' : '..');
+const MODULE_EXT = IS_COMPILED ? '.js' : '.ts';
+export const MCP_SERVER_PATH = resolve(SERVER_ROOT, `mcp/server${MODULE_EXT}`);
+export const APP_TOOLS_MCP_SERVER_PATH = resolve(SERVER_ROOT, `mcp/app-tools-mcp-server${MODULE_EXT}`);
+export const BROWSER_MCP_SERVER_PATH = resolve(SERVER_ROOT, `mcp/browser-mcp-server${MODULE_EXT}`);
+export const QUALITY_MCP_SERVER_PATH = resolve(SERVER_ROOT, `mcp/quality-mcp-server${MODULE_EXT}`);
+export function findSkillsDir(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 10; i++) {
+        const candidate = join(dir, '.claude', 'skills');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}

package/dist/server/utils/port-manager.js

@@ -0,0 +1,43 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createServer } from 'node:net';
+const DEFAULT_PORT = 3001;
+const MAX_PORT_ATTEMPTS = 10;
+async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port);
+    });
+}
+export async function findAvailablePort(startPort = DEFAULT_PORT) {
+    for (let i = 0; i < MAX_PORT_ATTEMPTS; i++) {
+        const port = startPort + i;
+        const available = await isPortAvailable(port);
+        if (available) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find available port after ${MAX_PORT_ATTEMPTS} attempts (tried ${startPort}-${startPort + MAX_PORT_ATTEMPTS - 1})`);
+}
+export function getDefaultPort() {
+    const envPort = process.env.PORT;
+    if (envPort) {
+        const parsed = parseInt(envPort, 10);
+        if (!Number.isNaN(parsed) && parsed > 0 && parsed < 65536) {
+            return parsed;
+        }
+    }
+    return DEFAULT_PORT;
+}