@monoes/monomindcli 2.9.22 → 2.9.24

package/dist/src/commands/status.js

@@ -2,11 +2,11 @@
  * CLI Status Command
  * System status display for Monomind
  */
-import { output } from '../output.js';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
+import { output } from '../output.js';
 // Status refresh interval (ms)
 const DEFAULT_WATCH_INTERVAL = 2000;
 // Track CPU usage over time
@@ -37,23 +37,31 @@ function isInitialized(cwd) {
     const configPath = path.join(cwd, '.monomind', 'config.yaml');
     return fs.existsSync(configPath);
 }
-// Format uptime
-function formatUptime(ms) {
-    const seconds = Math.floor(ms / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    if (days > 0) {
-        return `${days}d ${hours % 24}h ${minutes % 60}m`;
+// Check liveness of a pid via a zero-signal, matching the pattern used in
+// commands/start.ts (isPidAlive) / .claude/helpers/control-start.cjs.
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
     }
-    else if (hours > 0) {
-        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    catch {
+        return false;
     }
-    else if (minutes > 0) {
-        return `${minutes}m ${seconds % 60}s`;
+}
+// Whether the `monomind start --daemon` background process is actually
+// alive, determined by reading its real pid file — not assumed.
+function isDaemonRunning(cwd) {
+    const daemonPidPath = path.join(cwd, '.monomind', 'daemon.pid');
+    if (!fs.existsSync(daemonPidPath))
+        return false;
+    try {
+        const pid = Number(fs.readFileSync(daemonPidPath, 'utf-8').trim());
+        return isPidAlive(pid);
     }
-    else {
-        return `${seconds}s`;
+    catch {
+        return false;
     }
 }
 // Format bytes
@@ -63,13 +71,21 @@ function formatBytes(bytes) {
     const k = 1024;
     const sizes = ['B', 'KB', 'MB', 'GB'];
     const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+    return `${parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
 }
 // Get system status data
-async function getSystemStatus() {
+async function getSystemStatus(cwd) {
+    // Real daemon liveness — replaces a literal `running: true` that claimed
+    // "running" for every project where the MCP tool calls below happened not
+    // to throw, regardless of whether any Monomind process was actually alive.
+    const daemonRunning = isDaemonRunning(cwd);
     try {
-        // Get swarm status
-        const swarmStatus = await callMCPTool('swarm_status', { includeMetrics: true });
+        // Get monoswarm status. monoswarm_status genuinely returns: monoswarmId,
+        // status, topology, maxAgents, agentCount, taskCount, config, createdAt,
+        // updatedAt — no `agents.{total,active,idle}` object, no `health`, no
+        // `uptime`. Reading those non-existent fields used to resolve to
+        // `undefined`/`NaN` in the rendered table instead of throwing.
+        const swarmStatus = await callMCPTool('monoswarm_status', { verbose: true });
         // Get MCP status
         let mcpStatus = { running: false, port: null, transport: 'stdio' };
         try {
@@ -107,30 +123,24 @@ async function getSystemStatus() {
                     const { join } = await import('node:path');
                     memoryStatus.size = statSync(join(bridgeGetDbPath(), 'memory.db')).size;
                 }
-                catch { /* size is a nicety; entries and backend are the load-bearing parts */ }
+                catch {
+                    /* size is a nicety; entries and backend are the load-bearing parts */
+                }
             }
         }
-        catch { /* leaves backend 'unknown' — an honest "could not read" */ }
+        catch {
+            /* leaves backend 'unknown' — an honest "could not read" */
+        }
         // Get task status
         const taskStatus = await callMCPTool('task_summary', {});
         return {
             initialized: true,
-            running: true,
+            running: daemonRunning,
             swarm: {
-                id: swarmStatus.swarmId,
-                topology: swarmStatus.topology,
-                // swarm_status omits `agents` entirely when no swarm has been
-                // initialised — the common case in a fresh project. Reading
-                // .agents.total threw, and the catch below turned that into an
-                // all-zero "system not running" report for EVERY panel, including
-                // memory and tasks that were perfectly readable.
-                agents: {
-                    total: swarmStatus.agents?.total ?? 0,
-                    active: swarmStatus.agents?.active ?? 0,
-                    idle: swarmStatus.agents?.idle ?? 0
-                },
-                health: swarmStatus.health,
-                uptime: swarmStatus.uptime
+                id: swarmStatus.monoswarmId ?? null,
+                topology: swarmStatus.topology ?? 'none',
+                status: swarmStatus.status ?? 'no_swarm',
+                agents: { total: swarmStatus.agentCount ?? 0 },
             },
             mcp: mcpStatus,
             memory: {
@@ -139,15 +149,15 @@ async function getSystemStatus() {
                 backend: memoryStatus.backend,
                 performance: {
                     searchTime: memoryStatus.performance.avgSearchTime,
-                    cacheHitRate: memoryStatus.performance.cacheHitRate
-                }
+                    cacheHitRate: memoryStatus.performance.cacheHitRate,
+                },
             },
             tasks: taskStatus,
             performance: {
                 cpuUsage: getProcessCpuUsage(),
                 memoryUsage: getProcessMemoryUsage(),
-                searchSpeed: 'not measured'
-            }
+                searchSpeed: 'not measured',
+            },
         };
     }
     catch (error) {
@@ -165,27 +175,26 @@ async function getSystemStatus() {
         }
         return {
             initialized: true,
-            running: false,
+            running: daemonRunning,
             swarm: {
                 id: null,
                 topology: 'none',
-                agents: { total: 0, active: 0, idle: 0 },
-                health: 'stopped',
-                uptime: 0
+                status: 'no_swarm',
+                agents: { total: 0 },
             },
             mcp: { running: false, port: null, transport: 'stdio' },
             memory: {
                 entries: 0,
                 size: '0 B',
                 backend: 'none',
-                performance: { searchTime: 0, cacheHitRate: 0 }
+                performance: { searchTime: 0, cacheHitRate: 0 },
             },
             tasks: { total: 0, pending: 0, running: 0, completed: 0, failed: 0 },
             performance: {
                 cpuUsage: 0,
                 memoryUsage: 0,
-                searchSpeed: 'N/A'
-            }
+                searchSpeed: 'N/A',
+            },
         };
     }
 }
@@ -193,29 +202,28 @@ async function getSystemStatus() {
 async function displayStatus(status) {
     output.writeln();
     // Header with overall status
-    const statusIcon = status.running
-        ? output.success('[RUNNING]')
-        : output.warning('[STOPPED]');
+    const statusIcon = status.running ? output.success('[RUNNING]') : output.warning('[STOPPED]');
     output.writeln(`${output.bold('Monomind')} ${statusIcon}`);
     output.writeln();
-    // Swarm section
+    // Swarm section. monoswarm_status never returns a health verdict, an uptime,
+    // or an active/idle breakdown — only `status`/`topology`/`agentCount` — so
+    // those are the only fields shown here.
     output.writeln(output.bold('Swarm'));
-    if (status.running) {
+    if (status.swarm.id) {
         output.printTable({
             columns: [
                 { key: 'property', header: 'Property', width: 15 },
-                { key: 'value', header: 'Value', width: 30 }
+                { key: 'value', header: 'Value', width: 30 },
             ],
             data: [
                 { property: 'ID', value: status.swarm.id },
                 { property: 'Topology', value: status.swarm.topology },
-                { property: 'Health', value: formatHealth(status.swarm.health) },
-                { property: 'Uptime', value: formatUptime(status.swarm.uptime) }
-            ]
+                { property: 'Status', value: status.swarm.status },
+            ],
         });
     }
     else {
-        output.printInfo('  Swarm not running');
+        output.printInfo('  No active swarm');
     }
     output.writeln();
     // Agents section
@@ -223,13 +231,9 @@ async function displayStatus(status) {
     output.printTable({
         columns: [
             { key: 'status', header: 'Status', width: 12 },
-            { key: 'count', header: 'Count', width: 10, align: 'right' }
+            { key: 'count', header: 'Count', width: 10, align: 'right' },
         ],
-        data: [
-            { status: 'Active', count: status.swarm.agents.active },
-            { status: 'Idle', count: status.swarm.agents.idle },
-            { status: output.bold('Total'), count: status.swarm.agents.total }
-        ]
+        data: [{ status: output.bold('Total'), count: status.swarm.agents.total }],
     });
     output.writeln();
     // Tasks section
@@ -237,15 +241,15 @@ async function displayStatus(status) {
     output.printTable({
         columns: [
             { key: 'status', header: 'Status', width: 12 },
-            { key: 'count', header: 'Count', width: 10, align: 'right' }
+            { key: 'count', header: 'Count', width: 10, align: 'right' },
         ],
         data: [
             { status: 'Pending', count: status.tasks.pending },
             { status: 'Running', count: status.tasks.running },
             { status: 'Completed', count: status.tasks.completed },
             { status: 'Failed', count: status.tasks.failed },
-            { status: output.bold('Total'), count: status.tasks.total }
-        ]
+            { status: output.bold('Total'), count: status.tasks.total },
+        ],
     });
     output.writeln();
     // Memory section
@@ -253,15 +257,18 @@ async function displayStatus(status) {
     output.printTable({
         columns: [
             { key: 'property', header: 'Property', width: 18 },
-            { key: 'value', header: 'Value', width: 20, align: 'right' }
+            { key: 'value', header: 'Value', width: 20, align: 'right' },
         ],
         data: [
             { property: 'Backend', value: status.memory.backend },
             { property: 'Entries', value: status.memory.entries },
             { property: 'Size', value: status.memory.size },
             { property: 'Search Time', value: `${status.memory.performance.searchTime.toFixed(2)}ms` },
-            { property: 'Cache Hit Rate', value: `${(status.memory.performance.cacheHitRate * 100).toFixed(1)}%` }
-        ]
+            {
+                property: 'Cache Hit Rate',
+                value: `${(status.memory.performance.cacheHitRate * 100).toFixed(1)}%`,
+            },
+        ],
     });
     output.writeln();
     // MCP section
@@ -280,11 +287,11 @@ async function displayStatus(status) {
     output.writeln();
     // Performance section
     if (status.running) {
-        output.writeln(output.bold('v1 Performance Gains'));
+        output.writeln(output.bold('Performance'));
         output.printList([
             `Vector Search: ${output.success(status.performance.searchSpeed)}`,
             `CPU Usage: ${status.performance.cpuUsage.toFixed(1)}%`,
-            `Memory Usage: ${status.performance.memoryUsage.toFixed(1)}%`
+            `Memory Usage: ${status.performance.memoryUsage.toFixed(1)}%`,
         ]);
     }
     // System resources section
@@ -296,13 +303,16 @@ async function displayStatus(status) {
         output.printTable({
             columns: [
                 { key: 'property', header: 'Property', width: 18 },
-                { key: 'value', header: 'Value', width: 25, align: 'right' }
+                { key: 'value', header: 'Value', width: 25, align: 'right' },
             ],
             data: [
                 { property: 'Available RAM', value: memColor(`${res.freeMemMB}MB (${res.freeMemPct}%)`) },
                 { property: 'SDK Processes', value: `${res.sdkProcesses} / ${res.maxSdkProcesses} max` },
-                { property: 'Status', value: res.ok ? output.success('OK') : output.warning(res.reason ?? 'pressure') },
-            ]
+                {
+                    property: 'Status',
+                    value: res.ok ? output.success('OK') : output.warning(res.reason ?? 'pressure'),
+                },
+            ],
         });
     }
     catch {
@@ -327,7 +337,9 @@ function formatHealth(health) {
 const statusAction = async (ctx) => {
     const watch = ctx.flags.watch;
     const rawInterval = ctx.flags.interval || DEFAULT_WATCH_INTERVAL / 1000;
-    const interval = Number.isFinite(rawInterval) ? Math.max(1, Math.min(rawInterval, 3600)) : DEFAULT_WATCH_INTERVAL / 1000;
+    const interval = Number.isFinite(rawInterval)
+        ? Math.max(1, Math.min(rawInterval, 3600))
+        : DEFAULT_WATCH_INTERVAL / 1000;
     const healthCheck = ctx.flags['health-check'];
     const cwd = ctx.cwd;
     // Check initialization
@@ -337,7 +349,7 @@ const statusAction = async (ctx) => {
         return { success: false, exitCode: 1 };
     }
     // Get status
-    const status = await getSystemStatus();
+    const status = await getSystemStatus(cwd);
     // Health check mode
     if (healthCheck) {
         return performHealthCheck(status);
@@ -349,7 +361,7 @@ const statusAction = async (ctx) => {
     }
     // Watch mode
     if (watch) {
-        return watchStatus(interval);
+        return watchStatus(interval, cwd);
     }
     // Single status display
     await displayStatus(status);
@@ -365,58 +377,62 @@ async function performHealthCheck(status) {
     checks.push({
         name: 'System Running',
         status: status.running ? 'pass' : 'fail',
-        message: status.running ? 'System is running' : 'System is not running'
+        message: status.running ? 'System is running' : 'System is not running',
     });
     // Check swarm health
     if (status.running) {
         checks.push({
-            name: 'Swarm Health',
-            status: status.swarm.health === 'healthy' ? 'pass' :
-                status.swarm.health === 'degraded' ? 'warn' : 'fail',
-            message: `Swarm is ${status.swarm.health}`
+            name: 'Swarm Status',
+            status: status.swarm.status === 'running'
+                ? 'pass'
+                : status.swarm.status === 'no_swarm'
+                    ? 'fail'
+                    : 'warn',
+            message: `Swarm status: ${status.swarm.status}`,
         });
         // Check agent count
         checks.push({
             name: 'Agents Available',
-            status: status.swarm.agents.active > 0 ? 'pass' :
-                status.swarm.agents.idle > 0 ? 'warn' : 'fail',
-            message: `${status.swarm.agents.active} active, ${status.swarm.agents.idle} idle`
+            status: status.swarm.agents.total > 0 ? 'pass' : 'fail',
+            message: `${status.swarm.agents.total} agent(s)`,
         });
         // Check MCP
         checks.push({
             name: 'MCP Server',
             status: status.mcp.running ? 'pass' : 'warn',
             message: status.mcp.running
-                ? (status.mcp.transport === 'stdio' ? 'Running (stdio mode)' : `Running on port ${status.mcp.port}`)
-                : 'Not running'
+                ? status.mcp.transport === 'stdio'
+                    ? 'Running (stdio mode)'
+                    : `Running on port ${status.mcp.port}`
+                : 'Not running',
         });
         // Check memory backend
         checks.push({
             name: 'Memory Backend',
             status: status.memory.backend !== 'none' ? 'pass' : 'fail',
-            message: `Using ${status.memory.backend} backend`
+            message: `Using ${status.memory.backend} backend`,
         });
         // Check for failed tasks
-        const failRate = status.tasks.total > 0
-            ? status.tasks.failed / status.tasks.total
-            : 0;
+        const failRate = status.tasks.total > 0 ? status.tasks.failed / status.tasks.total : 0;
         checks.push({
             name: 'Task Success Rate',
             status: failRate < 0.05 ? 'pass' : failRate < 0.2 ? 'warn' : 'fail',
-            message: `${((1 - failRate) * 100).toFixed(1)}% success rate`
+            message: `${((1 - failRate) * 100).toFixed(1)}% success rate`,
         });
     }
     // Display results
     for (const check of checks) {
-        const icon = check.status === 'pass' ? output.success('[PASS]') :
-            check.status === 'warn' ? output.warning('[WARN]') :
-                output.error('[FAIL]');
+        const icon = check.status === 'pass'
+            ? output.success('[PASS]')
+            : check.status === 'warn'
+                ? output.warning('[WARN]')
+                : output.error('[FAIL]');
         output.writeln(`${icon} ${check.name}: ${check.message}`);
     }
     output.writeln();
-    const passed = checks.filter(c => c.status === 'pass').length;
-    const warned = checks.filter(c => c.status === 'warn').length;
-    const failed = checks.filter(c => c.status === 'fail').length;
+    const passed = checks.filter((c) => c.status === 'pass').length;
+    const warned = checks.filter((c) => c.status === 'warn').length;
+    const failed = checks.filter((c) => c.status === 'fail').length;
     if (failed === 0) {
         output.printSuccess(`All checks passed (${passed} passed, ${warned} warnings)`);
     }
@@ -426,11 +442,11 @@ async function performHealthCheck(status) {
     return {
         success: failed === 0,
         exitCode: failed > 0 ? 1 : 0,
-        data: { checks, summary: { passed, warned, failed } }
+        data: { checks, summary: { passed, warned, failed } },
     };
 }
 // Watch mode - continuous status updates
-async function watchStatus(intervalSeconds) {
+async function watchStatus(intervalSeconds, cwd) {
     output.writeln();
     output.writeln(output.bold('Watch Mode'));
     output.writeln(output.dim(`Refreshing every ${intervalSeconds}s. Press Ctrl+C to exit.`));
@@ -440,7 +456,7 @@ async function watchStatus(intervalSeconds) {
         process.stdout.write('\x1b[2J\x1b[H');
         output.writeln(output.dim(`Last updated: ${new Date().toLocaleTimeString()}`));
         output.writeln();
-        const status = await getSystemStatus();
+        const status = await getSystemStatus(cwd);
         await displayStatus(status);
     };
     // Initial display
@@ -465,6 +481,11 @@ const agentsCommand = {
     description: 'Show detailed agent status',
     action: async (ctx) => {
         try {
+            // agent_list (mcp-tools/agent-tools.ts) returns agentId/agentType/status/
+            // health/taskCount/createdAt/domain — it never returns `id`, `type`,
+            // `task`, `uptime`, or a `metrics.successRate` object. Reading
+            // `a.metrics.successRate` on the real shape threw a TypeError
+            // ("Cannot read properties of undefined") for every agent in the store.
             const result = await callMCPTool('agent_list', { includeMetrics: true, status: 'all' });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
@@ -482,18 +503,18 @@ const agentsCommand = {
                     { key: 'id', header: 'ID', width: 20 },
                     { key: 'type', header: 'Type', width: 12 },
                     { key: 'status', header: 'Status', width: 10 },
-                    { key: 'task', header: 'Current Task', width: 25 },
-                    { key: 'uptime', header: 'Uptime', width: 12 },
-                    { key: 'success', header: 'Success', width: 8 }
+                    { key: 'tasks', header: 'Tasks', width: 8 },
+                    { key: 'created', header: 'Created', width: 22 },
+                    { key: 'health', header: 'Health', width: 8 },
                 ],
-                data: result.agents.map(a => ({
-                    id: a.id,
-                    type: a.type,
-                    status: formatHealth(a.status),
-                    task: a.task || '-',
-                    uptime: formatUptime(a.uptime),
-                    success: `${(a.metrics.successRate * 100).toFixed(0)}%`
-                }))
+                data: result.agents.map((a) => ({
+                    id: a.agentId ?? 'N/A',
+                    type: a.agentType ?? 'N/A',
+                    status: a.status ? formatHealth(a.status) : 'N/A',
+                    tasks: a.taskCount ?? 'N/A',
+                    created: a.createdAt ?? 'N/A',
+                    health: typeof a.health === 'number' ? a.health.toFixed(2) : 'N/A',
+                })),
             });
             return { success: true, data: result };
         }
@@ -506,7 +527,7 @@ const agentsCommand = {
             }
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Tasks subcommand
 const tasksCommand = {
@@ -533,16 +554,16 @@ const tasksCommand = {
                     { key: 'status', header: 'Status', width: 12 },
                     { key: 'priority', header: 'Priority', width: 10 },
                     { key: 'agent', header: 'Agent', width: 15 },
-                    { key: 'progress', header: 'Progress', width: 10 }
+                    { key: 'progress', header: 'Progress', width: 10 },
                 ],
-                data: result.tasks.map(t => ({
+                data: result.tasks.map((t) => ({
                     id: t.id,
                     type: t.type,
                     status: formatHealth(t.status),
                     priority: t.priority,
                     agent: t.agent || '-',
-                    progress: `${t.progress}%`
-                }))
+                    progress: `${t.progress}%`,
+                })),
             });
             return { success: true, data: result };
         }
@@ -555,7 +576,7 @@ const tasksCommand = {
             }
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Memory subcommand
 const memoryCommand = {
@@ -583,13 +604,13 @@ const memoryCommand = {
             output.printTable({
                 columns: [
                     { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 25 }
+                    { key: 'value', header: 'Value', width: 25 },
                 ],
                 data: [
                     { property: 'Backend', value: result.backend },
                     { property: 'Total Entries', value: result.entries.toLocaleString() },
                     { property: 'Storage Size', value: formatBytes(result.size) },
-                ]
+                ],
             });
             return { success: true, data: result };
         }
@@ -597,7 +618,7 @@ const memoryCommand = {
             output.printError(`Failed to get memory status: ${error instanceof Error ? error.message : String(error)}`);
             return { success: false, exitCode: 1 };
         }
-    }
+    },
 };
 // Main status command
 export const statusCommand = {
@@ -610,21 +631,21 @@ export const statusCommand = {
             short: 'w',
             description: 'Watch mode - continuously update status',
             type: 'boolean',
-            default: false
+            default: false,
         },
         {
             name: 'interval',
             short: 'i',
             description: 'Watch mode update interval in seconds',
             type: 'number',
-            default: 2
+            default: 2,
         },
         {
             name: 'health-check',
             description: 'Perform health checks and exit',
             type: 'boolean',
-            default: false
-        }
+            default: false,
+        },
     ],
     examples: [
         { command: 'monomind status', description: 'Show current system status' },
@@ -634,9 +655,9 @@ export const statusCommand = {
         { command: 'monomind status --json', description: 'Output status as JSON' },
         { command: 'monomind status agents', description: 'Show detailed agent status' },
         { command: 'monomind status tasks', description: 'Show detailed task status' },
-        { command: 'monomind status memory', description: 'Show detailed memory status' }
+        { command: 'monomind status memory', description: 'Show detailed memory status' },
     ],
-    action: statusAction
+    action: statusAction,
 };
 export default statusCommand;
 //# sourceMappingURL=status.js.map