@markus-global/cli 0.4.18 → 0.4.20

package/dist/commands/start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/commands/start.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkDzC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAqBpD"}
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/commands/start.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwDzC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAqBpD"}

package/dist/commands/start.js

@@ -2,9 +2,9 @@ import { resolve, join, dirname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { allTemplateDirs, resolveTemplatesDir, resolveWebUiDir } from '../paths.js';
-import { loadConfig, getDefaultConfigPath, createLogger, closeRuntimeLogger, } from '@markus/shared';
+import { loadConfig, getDefaultConfigPath, createLogger, closeRuntimeLogger, checkForUpdate, TRIAGE_MAX_TOKENS, TRIAGE_TEMPERATURE, TRIAGE_ALLOWED_TOOLS, } from '@markus/shared';
 import { AgentManager, LLMRouter, LLMLogger, RoleLoader, createDefaultSkillRegistry, ExternalAgentGateway, } from '@markus/core';
-import { OrganizationService, TaskService, APIServer, HITLService, BillingService, AuditService, ProjectService, RequirementService, KnowledgeService, FileKnowledgeStore, DeliverableService, ReportService, TrustService, ScheduledTaskRunner, initStorage, searchRegistries, installSkill, } from '@markus/org-manager';
+import { OrganizationService, TaskService, APIServer, HITLService, BillingService, AuditService, ProjectService, RequirementService, KnowledgeService, FileKnowledgeStore, DeliverableService, ReportService, TrustService, ArchiveService, ScheduledTaskRunner, initStorage, searchRegistries, installSkill, } from '@markus/org-manager';
 import { MessageRouter, FeishuAdapter, WebUIAdapter } from '@markus/comms';
 import { initStartupLogger, startupLog, startupBlank, startupSection, closeStartupLogger, getStartupLogFile } from '../utils/logger.js';
 import { openBrowser } from '../utils/browser.js';
@@ -177,6 +177,15 @@ async function createServices(config) {
     if (config.agent?.maxToolIterations) {
         agentManager.maxToolIterations = config.agent.maxToolIterations;
     }
+    if (config.browser?.bringToFront !== undefined) {
+        agentManager.setBrowserBringToFront(config.browser.bringToFront);
+    }
+    if (config.browser?.autoCloseTabs !== undefined) {
+        agentManager.setBrowserAutoCloseTabs(config.browser.autoCloseTabs);
+    }
+    if (config.browser?.remoteDebuggingPort) {
+        agentManager.setBrowserRemoteDebuggingPort(config.browser.remoteDebuggingPort);
+    }
     taskService.setAgentManager(agentManager);
     const orgService = new OrganizationService(agentManager, roleLoader, storage ?? undefined);
     taskService.setOrgService(orgService);
@@ -306,6 +315,9 @@ async function startServer(config, values) {
     if (storage?.notificationRepo) {
         hitlService.setNotificationRepo(storage.notificationRepo);
     }
+    if (storage?.approvalRepo) {
+        hitlService.setApprovalRepo(storage.approvalRepo);
+    }
     if (storage?.projectRepo) {
         projectService.setProjectRepo(storage.projectRepo);
     }
@@ -340,6 +352,10 @@ async function startServer(config, values) {
     // Wire ProjectService into TaskService (workspace management is handled by agents)
     taskService.setProjectService(projectService);
     taskService.setRequirementService(requirementService);
+    // Auto-archive: archive terminal tasks and requirements after configured thresholds
+    const archiveService = new ArchiveService(taskService, projectService);
+    archiveService.setRequirementService(requirementService);
+    archiveService.start();
     // Expose LLM router to API server so settings can read/write it at runtime
     apiServer.setLLMRouter(llmRouter);
     apiServer.setConfigPath(values['config'] ?? getDefaultConfigPath());
@@ -372,6 +388,16 @@ async function startServer(config, values) {
     if (hubClient) {
         agentManager.setHubClient(hubClient);
     }
+    // Wire team/agent update callbacks for manager tools
+    agentManager.setTeamUpdater(async (teamId, data) => {
+        const team = await orgService.updateTeam(teamId, data);
+        return { id: teamId, name: team.name, description: team.description };
+    });
+    if (storage) {
+        agentManager.setAgentConfigPersister(async (agentId, data) => {
+            await storage.agentRepo.updateConfig(agentId, data);
+        });
+    }
     // Wire skill search/install callbacks so agents can discover and install remote skills
     agentManager.setSkillSearcher(async (query) => searchRegistries(query));
     agentManager.setSkillInstaller(async (request) => {
@@ -388,50 +414,20 @@ async function startServer(config, values) {
         }, skillRegistry);
         return { installed: result.installed, name: result.name, method: result.method };
     });
-    // Wire proactive user message senders and chat session fetchers for agents
-    if (storage?.chatSessionRepo) {
-        const ws = apiServer.getWSBroadcaster();
-        const wireAgentChatIntegration = (agentId) => {
-            try {
-                const agent = agentManager.getAgent(agentId);
-                agentManager.setUserMessageSender(agentId, async (message, opts) => {
-                    let sessionId;
-                    if (opts?.sessionId) {
-                        sessionId = opts.sessionId;
-                    }
-                    else {
-                        const sessions = await storage.chatSessionRepo.getSessionsByAgent(agentId);
-                        if (sessions.length > 0) {
-                            sessionId = sessions[0].id;
-                        }
-                        else {
-                            const newSess = await storage.chatSessionRepo.createSession(agentId);
-                            sessionId = newSess.id;
-                        }
-                    }
-                    const msg = await storage.chatSessionRepo.appendMessage(sessionId, agentId, 'assistant', message);
-                    ws.broadcastProactiveMessage(agentId, agent.config.name, sessionId, msg.id, message);
-                    return { sessionId, messageId: msg.id };
-                });
-                agentManager.setChatSessionsFetcher(agentId, async () => {
-                    const sessions = await storage.chatSessionRepo.getSessionsByAgent(agentId);
-                    return sessions.slice(0, 5).map((s) => ({
-                        id: s.id,
-                        title: s.title,
-                        lastMessageAt: s.lastMessageAt ?? s.createdAt ?? new Date().toISOString(),
-                        lastMessagePreview: s.lastMessagePreview,
-                    }));
-                });
-            }
-            catch { /* agent not found */ }
-        };
-        for (const info of agentManager.listAgents())
-            wireAgentChatIntegration(info.id);
-        agentManager.getEventBus().on('agent:created', (evt) => {
-            const { agentId } = evt;
-            wireAgentChatIntegration(agentId);
+    // Wire user approval requester through HITL service
+    agentManager.setUserApprovalRequester(async (opts) => {
+        return hitlService.requestApprovalAndWait({
+            agentId: opts.agentId,
+            agentName: opts.agentName,
+            type: 'custom',
+            title: opts.title,
+            description: opts.description,
+            targetUserId: 'default',
+            options: opts.options,
+            allowFreeform: opts.allowFreeform,
+            details: { priority: opts.priority, taskId: opts.relatedTaskId },
         });
-    }
+    });
     // Wire user notifier through HITL service
     agentManager.setUserNotifier((opts) => {
         hitlService.notify({
@@ -447,6 +443,13 @@ async function startServer(config, values) {
     });
     // Ensure every agent has a main session on startup, then persist activity logs to it
     if (storage?.chatSessionRepo) {
+        // Migrate legacy assistant messages that lack segments metadata
+        try {
+            storage.chatSessionRepo.migrateLegacyMessages();
+        }
+        catch (e) {
+            log.warn('Legacy chat message migration failed', { error: String(e) });
+        }
         for (const info of agentManager.listAgents()) {
             try {
                 storage.chatSessionRepo.getOrCreateMainSession(info.id);
@@ -457,15 +460,77 @@ async function startServer(config, values) {
         agentManager.getEventBus().on('agent:activity-log', async (evt) => {
             const { agentId, message, metadata } = evt;
             try {
-                const mainSession = await storage.chatSessionRepo.getOrCreateMainSession(agentId);
-                const msg = await storage.chatSessionRepo.appendMessage(mainSession.id, agentId, 'assistant', message, 0, metadata);
+                const mainSession = storage.chatSessionRepo.getOrCreateMainSession(agentId);
+                const msg = storage.chatSessionRepo.appendMessage(mainSession.id, agentId, 'assistant', message, 0, metadata);
+                storage.chatSessionRepo.updateLastMessage(mainSession.id);
                 const agent = agentManager.getAgent(agentId);
-                ws.broadcastProactiveMessage(agentId, agent.config.name, mainSession.id, msg.id, message);
+                ws.broadcastProactiveMessage(agentId, agent.config.name, mainSession.id, msg.id, message, {
+                    ...metadata,
+                    isMainSession: true,
+                });
             }
             catch (e) {
                 log.warn('Failed to persist activity log', { agentId, error: String(e) });
             }
         });
+        // notify_user: persist as regular chat message + WS broadcast + notification bell
+        agentManager.getEventBus().on('agent:notify-user', async (evt) => {
+            const { agentId, title, body, priority, taskId, requirementId } = evt;
+            try {
+                const mainSession = storage.chatSessionRepo.getOrCreateMainSession(agentId);
+                const agent = agentManager.getAgent(agentId);
+                const formattedMsg = `**${title}**\n\n${body}`;
+                const msg = storage.chatSessionRepo.appendMessage(mainSession.id, agentId, 'assistant', formattedMsg, 0, {});
+                storage.chatSessionRepo.updateLastMessage(mainSession.id);
+                ws.broadcastProactiveMessage(agentId, agent.config.name, mainSession.id, msg.id, formattedMsg, {
+                    isMainSession: true,
+                });
+                const hasTask = !!taskId;
+                hitlService.notify({
+                    targetUserId: 'default',
+                    type: 'agent_report',
+                    title, body, priority,
+                    actionType: hasTask ? 'navigate' : 'open_chat',
+                    actionTarget: hasTask
+                        ? JSON.stringify({ path: `/work?openTask=${taskId}` })
+                        : JSON.stringify({ agentId, sessionId: mainSession.id }),
+                    metadata: { agentId, agentName: agent.config.name, taskId, requirementId, sessionId: mainSession.id },
+                });
+            }
+            catch (e) {
+                log.warn('Failed to handle notify-user event', { agentId, error: String(e) });
+            }
+        });
+        // escalation: persist as regular chat message + WS broadcast + notification + audit
+        agentManager.getEventBus().on('agent:escalation', async (evt) => {
+            const { agentId, reason } = evt;
+            try {
+                const mainSession = storage.chatSessionRepo.getOrCreateMainSession(agentId);
+                const agent = agentManager.getAgent(agentId);
+                const formattedMsg = `**I need help**\n\n${reason}`;
+                const msg = storage.chatSessionRepo.appendMessage(mainSession.id, agentId, 'assistant', formattedMsg, 0, {});
+                storage.chatSessionRepo.updateLastMessage(mainSession.id);
+                ws.broadcastProactiveMessage(agentId, agent.config.name, mainSession.id, msg.id, formattedMsg, {
+                    isMainSession: true,
+                });
+                hitlService.notify({
+                    targetUserId: 'default',
+                    type: 'system',
+                    title: 'Agent needs help',
+                    body: reason,
+                    priority: 'high',
+                    actionType: 'open_chat',
+                    actionTarget: JSON.stringify({ agentId, sessionId: mainSession.id }),
+                    metadata: { agentId, sessionId: mainSession.id },
+                });
+                auditService.record({
+                    orgId: 'default', agentId, type: 'error', action: 'escalation', detail: reason, success: false,
+                });
+            }
+            catch (e) {
+                log.warn('Failed to handle escalation event', { agentId, error: String(e) });
+            }
+        });
         // Also create main session for newly created agents
         agentManager.getEventBus().on('agent:created', (evt) => {
             const { agentId } = evt;
@@ -475,17 +540,7 @@ async function startServer(config, values) {
             catch { /* skip */ }
         });
     }
-    // Auto-resume in_progress tasks after agents are fully loaded.
-    // Tasks retain their execution history in DB (task_logs + comments),
-    // so the agent receives full previous context on resume.
-    setTimeout(async () => {
-        try {
-            await taskService.resumeInProgressTasks();
-        }
-        catch (err) {
-            log.warn('Failed to auto-resume in_progress tasks', { error: String(err) });
-        }
-    }, 3000);
+    // Task resume is triggered after agents finish starting (see below).
     // Wire External Agent Gateway for OpenClaw integration
     const gatewaySecret = config.security?.gatewaySecret ?? process.env['GATEWAY_SECRET'] ?? 'markus-gateway-default-secret-change-me';
     const gateway = new ExternalAgentGateway({ signingSecret: gatewaySecret });
@@ -577,23 +632,10 @@ async function startServer(config, values) {
     deliverableService.setWSBroadcaster(apiServer.getWSBroadcaster());
     const scheduledTaskRunner = new ScheduledTaskRunner(taskService);
     scheduledTaskRunner.start();
+    // Escalation callback kept for agent-internal state management; actual notification/DB/WS/audit
+    // logic is handled by the 'agent:escalation' event handler registered above.
     agentManager.setEscalationHandler((agentId, reason) => {
         log.warn('Agent escalation', { agentId, reason });
-        hitlService.notify({
-            targetUserId: 'default',
-            type: 'system',
-            title: 'Agent needs help',
-            body: reason,
-            priority: 'high',
-        });
-        auditService.record({
-            orgId: 'default',
-            agentId,
-            type: 'error',
-            action: 'escalation',
-            detail: reason,
-            success: false,
-        });
     });
     agentManager.setApprovalHandler(async (agentId, request) => {
         const agents = agentManager.listAgents();
@@ -611,7 +653,6 @@ async function startServer(config, values) {
             description: request.reason,
             details: { ...request.toolArgs, toolName: request.toolName, agentId, taskId: request.taskId },
             targetUserId: 'default',
-            expiresInMs: 5 * 60 * 1000, // 5 minutes
         });
         auditService.record({
             orgId: 'default',
@@ -725,6 +766,24 @@ async function startServer(config, values) {
                 }
             },
         });
+        // Wire recall_activity tool to query execution history from SQLite
+        agentManager.setRecallCallbacks({
+            listActivities: (agentId, opts) => {
+                const results = actRepo.queryActivities(agentId, {
+                    type: opts.type,
+                    limit: opts.limit,
+                });
+                if (opts.taskId)
+                    return results.filter((a) => a.taskId === opts.taskId);
+                return results;
+            },
+            getActivityLogs: (activityId) => {
+                return actRepo.getActivityLogs(activityId);
+            },
+            searchActivities: (agentId, query, opts) => {
+                return actRepo.searchActivities(agentId, query, opts);
+            },
+        });
     }
     // Wire mailbox + decision persistence to SQLite
     if (storage?.mailboxRepo && storage?.decisionRepo) {
@@ -737,11 +796,12 @@ async function startServer(config, values) {
                 mailbox.setPersistence({
                     save: (item) => {
                         try {
+                            const { responsePromise, ...persistableMetadata } = (item.metadata ?? {});
                             mbRepo.save({
                                 id: item.id, agentId: item.agentId, sourceType: item.sourceType,
                                 priority: item.priority, status: item.status,
                                 payload: item.payload,
-                                metadata: (item.metadata ?? {}),
+                                metadata: persistableMetadata,
                                 queuedAt: item.queuedAt,
                             });
                         }
@@ -758,10 +818,46 @@ async function startServer(config, values) {
                         }
                     },
                     markStaleProcessingAsDropped: (aid) => mbRepo.markStaleProcessingAsDropped(aid),
+                    loadQueued: (aid) => {
+                        const rows = mbRepo.getByAgent(aid, { status: 'queued' });
+                        return rows.map((r) => ({
+                            id: r.id,
+                            agentId: r.agentId,
+                            sourceType: r.sourceType,
+                            priority: r.priority,
+                            status: r.status,
+                            payload: r.payload,
+                            metadata: r.metadata,
+                            queuedAt: r.queuedAt,
+                            startedAt: r.startedAt ?? undefined,
+                            completedAt: r.completedAt ?? undefined,
+                            deferredUntil: r.deferredUntil ?? undefined,
+                            mergedInto: r.mergedInto ?? undefined,
+                            retryCount: r.retryCount ?? 0,
+                        }));
+                    },
+                    loadDeferred: (aid) => {
+                        const rows = mbRepo.getByAgent(aid, { status: 'deferred' });
+                        return rows.map((r) => ({
+                            id: r.id,
+                            agentId: r.agentId,
+                            sourceType: r.sourceType,
+                            priority: r.priority,
+                            status: r.status,
+                            payload: r.payload,
+                            metadata: r.metadata,
+                            queuedAt: r.queuedAt,
+                            startedAt: r.startedAt ?? undefined,
+                            completedAt: r.completedAt ?? undefined,
+                            deferredUntil: r.deferredUntil ?? undefined,
+                            mergedInto: r.mergedInto ?? undefined,
+                            retryCount: r.retryCount ?? 0,
+                        }));
+                    },
                 });
-                const dropped = mailbox.recoverStaleItems();
-                if (dropped > 0)
-                    log.info('Recovered stale processing mailbox items', { agentId, dropped });
+                const { dropped, restored, expired, merged } = mailbox.recoverStaleItems();
+                if (dropped > 0 || restored > 0 || expired > 0 || merged > 0)
+                    log.info('Mailbox recovery on startup', { agentId, dropped, restored, expired, merged });
                 agent.getAttentionController().setDecisionPersistence({
                     save: (decision) => {
                         try {
@@ -779,6 +875,52 @@ async function startServer(config, values) {
                         }
                     },
                 });
+                // Wire TriageJudge — uses the agent's configured LLM provider
+                const triageProvider = agent.config.llmConfig?.modelMode === 'custom'
+                    ? agent.config.llmConfig.primary : undefined;
+                agent.getAttentionController().setTriageJudge(async (prompt) => {
+                    const response = await llmRouter.chat({
+                        messages: [
+                            { role: 'system', content: 'You are a mailbox triage assistant. Output ONLY a single JSON object — no explanation, no markdown fences, no <think> tags. Start your response with {' },
+                            { role: 'user', content: prompt },
+                        ],
+                        temperature: TRIAGE_TEMPERATURE,
+                        maxTokens: TRIAGE_MAX_TOKENS,
+                    }, triageProvider);
+                    return response.content;
+                });
+                // Wire triage chat function (for mini tool loop during triage)
+                agent.getAttentionController().setTriageChatFn(async (messages, tools) => {
+                    const llmTools = tools?.map(t => ({
+                        name: t.name,
+                        description: t.description,
+                        inputSchema: t.inputSchema,
+                    }));
+                    const response = await llmRouter.chat({
+                        messages: messages,
+                        tools: llmTools,
+                        temperature: TRIAGE_TEMPERATURE,
+                        maxTokens: TRIAGE_MAX_TOKENS,
+                    }, triageProvider);
+                    return { content: response.content, toolCalls: response.toolCalls };
+                });
+                // Wire read-only triage tools from the agent's tool set
+                const triageToolMap = new Map();
+                const agentTools = agent.getTools();
+                for (const toolName of TRIAGE_ALLOWED_TOOLS) {
+                    const handler = agentTools.get(toolName);
+                    if (handler) {
+                        triageToolMap.set(toolName, {
+                            name: handler.name,
+                            description: handler.description,
+                            inputSchema: handler.inputSchema,
+                            execute: handler.execute.bind(handler),
+                        });
+                    }
+                }
+                if (triageToolMap.size > 0) {
+                    agent.getAttentionController().setTriageTools(triageToolMap);
+                }
             }
             catch { /* agent not found */ }
         };
@@ -850,6 +992,10 @@ async function startServer(config, values) {
         const ws = apiServer.getWSBroadcaster();
         ws.broadcast({ type: 'agent:focus', payload: event, timestamp: new Date().toISOString() });
     });
+    eventBus.on('attention:triage', (event) => {
+        const ws = apiServer.getWSBroadcaster();
+        ws.broadcast({ type: 'agent:triage', payload: event, timestamp: new Date().toISOString() });
+    });
     // Wire agent lifecycle events to WS broadcast
     eventBus.on('agent:removed', (event) => {
         const { agentId } = event;
@@ -992,12 +1138,28 @@ async function startServer(config, values) {
     else {
         progress.finish(uiUrl);
     }
-    // Start restored agents in background (server is already accepting requests)
-    orgService.startRestoredAgentsInBackground();
+    // Non-blocking update check — runs after startup, never blocks or throws
+    checkForUpdate().then(info => {
+        if (info.updateAvailable) {
+            console.log(`\n  \x1b[33m⬆ New version available: v${info.latestVersion} (current: v${info.currentVersion})\x1b[0m`);
+            console.log(`    Run \x1b[1mnpm i -g @markus-global/cli\x1b[0m to upgrade\n`);
+        }
+    }).catch(() => { });
+    // Start restored agents in background (server is already accepting requests),
+    // then auto-resume in_progress tasks once all agents are ready.
+    orgService.startRestoredAgentsInBackground().then(async () => {
+        try {
+            await taskService.resumeInProgressTasks();
+        }
+        catch (err) {
+            log.warn('Failed to auto-resume in_progress tasks', { error: String(err) });
+        }
+    });
     process.on('SIGINT', () => {
         console.error('\nShutting down...');
         closeStartupLogger();
         closeRuntimeLogger();
+        archiveService.stop();
         scheduledTaskRunner.stop();
         apiServer.stop();
         agentManager.shutdown()