4runr-os 1.0.100 → 1.0.102

package/dist/ui/v3/commands/commandEngine.js

@@ -15,6 +15,11 @@
  * - Side-effect free
  * - Deterministic
  */
+import { available, unavailable } from '../state/value.js';
+import { listAgents, getAgent, createAgent as v1CreateAgent } from '../v1Adapters/agents.js';
+import { connect as v1Connect, getConnectionState } from '../v1Adapters/connect.js';
+import { startRun, listRuns } from '../v1Adapters/runs.js';
+import { loadConfig } from '../v1Adapters/config.js';
 /**
  * UI actions that the UI layer interprets
  */
@@ -66,10 +71,6 @@ export function parse(line) {
             }
             else {
                 // Start of double-quoted string
-                if (current.trim()) {
-                    tokens.push(current.trim());
-                    current = '';
-                }
                 inDoubleQuote = true;
             }
         }
@@ -82,17 +83,13 @@ export function parse(line) {
             }
             else {
                 // Start of single-quoted string
-                if (current.trim()) {
-                    tokens.push(current.trim());
-                    current = '';
-                }
                 inSingleQuote = true;
             }
         }
         else if ((char === ' ' || char === '\t') && !inDoubleQuote && !inSingleQuote) {
-            // Whitespace outside quotes - split token
-            if (current.trim()) {
-                tokens.push(current.trim());
+            // Whitespace outside quotes - end current token
+            if (current) {
+                tokens.push(current);
                 current = '';
             }
         }
@@ -102,8 +99,8 @@ export function parse(line) {
         }
     }
     // Add final token if any
-    if (current.trim() || inDoubleQuote || inSingleQuote) {
-        tokens.push(current.trim());
+    if (current || inDoubleQuote || inSingleQuote) {
+        tokens.push(current);
     }
     if (tokens.length === 0) {
         return { name: '', args: [], raw };
@@ -124,7 +121,7 @@ export function parse(line) {
  * - Never emits UI output directly
  * - Only side effects via returned data
  */
-export function execute(parsed, ctx) {
+export async function execute(parsed, ctx) {
     // Empty command
     if (!parsed.name) {
         return { events: [] };
@@ -136,7 +133,9 @@ export function execute(parsed, ctx) {
         return handleUnknown(parsed.name);
     }
     try {
-        return handler(ctx, parsed.args);
+        const result = handler(ctx, parsed.args);
+        // Handle both sync and async handlers
+        return await Promise.resolve(result);
     }
     catch (error) {
         // Handler error - emit error event
@@ -146,6 +145,7 @@ export function execute(parsed, ctx) {
                     id: `err-${Date.now()}`,
                     ts: Date.now(),
                     tag: 'ERR',
+                    level: 'ERROR',
                     msg: `Command error: ${errorMsg.substring(0, 50)}`,
                 }],
         };
@@ -180,6 +180,7 @@ function handleUnknown(cmd) {
                 id: `err-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'ERR',
+                level: 'ERROR',
                 msg: `UNKNOWN COMMAND: ${sanitizedCmd} (try: help)`,
             }],
     };
@@ -194,6 +195,12 @@ const commands = {
     clear: handleClear,
     home: handleHome,
     exit: handleExit,
+    // Section 6: Real commands (V1-backed)
+    'agents': handleAgents,
+    'connect': handleConnect,
+    'start': handleStart,
+    'runs': handleRuns,
+    'system': handleSystem,
 };
 /**
  * Handle help command
@@ -208,32 +215,86 @@ function handleHelp(ctx, args) {
                 id: `help-1-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'SYS',
+                level: 'INFO',
                 msg: 'AVAILABLE COMMANDS:',
             },
             {
                 id: `help-2-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'SYS',
+                level: 'INFO',
                 msg: ' help',
             },
             {
                 id: `help-3-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'SYS',
+                level: 'INFO',
                 msg: ' clear',
             },
             {
                 id: `help-4-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'SYS',
+                level: 'INFO',
                 msg: ' home',
             },
             {
                 id: `help-5-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'SYS',
+                level: 'INFO',
                 msg: ' exit',
             },
+            {
+                id: `help-6-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' agents list',
+            },
+            {
+                id: `help-7-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' agents create',
+            },
+            {
+                id: `help-8-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' agents inspect <id>',
+            },
+            {
+                id: `help-9-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' connect <target>',
+            },
+            {
+                id: `help-10-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' start <agentId>',
+            },
+            {
+                id: `help-11-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' runs list',
+            },
+            {
+                id: `help-12-${Date.now()}`,
+                ts: Date.now(),
+                tag: 'SYS',
+                level: 'INFO',
+                msg: ' system',
+            },
         ],
     };
 }
@@ -264,6 +325,7 @@ function handleHome(ctx, args) {
                 id: `home-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'SYS',
+                level: 'INFO',
                 msg: 'HOME VIEW',
             },
         ],
@@ -283,10 +345,635 @@ function handleExit(ctx, args) {
                 id: `exit-${Date.now()}`,
                 ts: Date.now(),
                 tag: 'SYS',
+                level: 'INFO',
                 msg: 'Exiting...',
             },
         ],
         action: UiAction.EXIT,
     };
 }
+// ============================================================================
+// Section 6: Real Commands (V1-Backed)
+// ============================================================================
+/**
+ * Handle agents command (list, create, inspect)
+ */
+async function handleAgents(ctx, args) {
+    const subcommand = args[0]?.toLowerCase() || 'list';
+    if (subcommand === 'list') {
+        return handleAgentsList(ctx, args.slice(1));
+    }
+    else if (subcommand === 'create') {
+        return handleAgentsCreate(ctx, args.slice(1));
+    }
+    else if (subcommand === 'inspect') {
+        return handleAgentsInspect(ctx, args.slice(1));
+    }
+    else {
+        return {
+            events: [{
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Unknown agents subcommand: ${subcommand} (try: list, create, inspect)`,
+                }],
+        };
+    }
+}
+/**
+ * 1️⃣ agents list
+ *
+ * Calls v1Adapters/agents.listAgents()
+ * Updates assets → AVAILABLE with real counts
+ */
+async function handleAgentsList(ctx, args) {
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: 'agents list',
+    };
+    try {
+        const result = listAgents();
+        if (!result.ok) {
+            // Failure: assets → UNAVAILABLE
+            return {
+                events: [
+                    cmdEvent,
+                    {
+                        id: `err-${Date.now()}`,
+                        ts: Date.now(),
+                        tag: 'ERR',
+                        level: 'ERROR',
+                        msg: `Failed to list agents: ${result.error.message}`,
+                    },
+                ],
+                uiStateUpdate: (prev) => ({
+                    ...prev,
+                    assets: unavailable(result.error.message || 'Agent registry unavailable', result.error.nextAction || 'Run "agents create"'),
+                }),
+            };
+        }
+        const agents = result.data;
+        const count = agents.length;
+        // Success: assets → AVAILABLE
+        const assetsState = {
+            total: count,
+            active: 0, // TODO: track active agents
+            idle: count,
+            error: 0,
+        };
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `ok-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: count === 0 ? 'SYS' : 'CMD',
+                    level: count === 0 ? 'WARN' : 'INFO',
+                    msg: count === 0 ? 'No agents found' : `${count} agent${count === 1 ? '' : 's'} found`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                assets: available(assetsState),
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Failed to list agents: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                assets: unavailable('Agent registry unavailable', 'Run "agents create"'),
+            }),
+        };
+    }
+}
+/**
+ * 2️⃣ agents create
+ *
+ * Accepts arguments or minimal defaults
+ * Calls v1Adapters/agents.createAgent()
+ */
+async function handleAgentsCreate(ctx, args) {
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: 'agents create',
+    };
+    try {
+        // Parse agent name from args (first arg)
+        const name = args[0]?.trim();
+        if (!name) {
+            return {
+                events: [
+                    cmdEvent,
+                    {
+                        id: `err-${Date.now()}`,
+                        ts: Date.now(),
+                        tag: 'ERR',
+                        level: 'ERROR',
+                        msg: 'Agent name required (usage: agents create <name>)',
+                    },
+                ],
+            };
+        }
+        // Create minimal agent (can be extended later)
+        const agent = {
+            name,
+            description: args[1] || undefined,
+            provider: {
+                type: 'openai',
+                model: 'gpt-3.5-turbo',
+            },
+        };
+        const result = v1CreateAgent(agent);
+        if (!result.ok) {
+            return {
+                events: [
+                    cmdEvent,
+                    {
+                        id: `err-${Date.now()}`,
+                        ts: Date.now(),
+                        tag: 'ERR',
+                        level: 'ERROR',
+                        msg: `Failed to create agent: ${result.error.message}`,
+                    },
+                ],
+                uiStateUpdate: (prev) => ({
+                    ...prev,
+                    assets: unavailable(result.error.message || 'Failed to create agent', result.error.nextAction || 'Check config and retry'),
+                }),
+            };
+        }
+        // Success: refresh assets list
+        const listResult = listAgents();
+        const assetsState = listResult.ok ? {
+            total: listResult.data.length,
+            active: 0,
+            idle: listResult.data.length,
+            error: 0,
+        } : {
+            total: 0,
+            active: 0,
+            idle: 0,
+            error: 0,
+        };
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `ok-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'CMD',
+                    level: 'INFO',
+                    msg: `Agent "${name}" created`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                assets: available(assetsState),
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Failed to create agent: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                assets: unavailable('Failed to create agent', 'Check config and retry'),
+            }),
+        };
+    }
+}
+/**
+ * 3️⃣ agents inspect <id>
+ *
+ * Calls v1Adapters/agents.getAgent(id)
+ * Updates posture → AVAILABLE
+ */
+async function handleAgentsInspect(ctx, args) {
+    const agentId = args[0]?.trim();
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: `agents inspect ${agentId || ''}`,
+    };
+    if (!agentId) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: 'Agent ID required (usage: agents inspect <id>)',
+                },
+            ],
+        };
+    }
+    try {
+        const result = getAgent(agentId);
+        if (!result.ok) {
+            return {
+                events: [
+                    cmdEvent,
+                    {
+                        id: `err-${Date.now()}`,
+                        ts: Date.now(),
+                        tag: 'ERR',
+                        level: 'ERROR',
+                        msg: `Agent not found: ${agentId}`,
+                    },
+                ],
+                uiStateUpdate: (prev) => ({
+                    ...prev,
+                    posture: unavailable(result.error.message || 'Agent not found', result.error.nextAction || 'Run "agents list"'),
+                }),
+            };
+        }
+        // Success: posture → AVAILABLE
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `ok-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'CMD',
+                    level: 'INFO',
+                    msg: `Agent loaded: ${result.data.name}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                posture: available({
+                    mode: 'HUB',
+                }),
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Failed to inspect agent: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                posture: unavailable('Agent not found', 'Run "agents list"'),
+            }),
+        };
+    }
+}
+/**
+ * 4️⃣ connect <target>
+ *
+ * Calls v1Adapters/connect.connect(target)
+ * Updates network → AVAILABLE, capabilities → AVAILABLE, statusStrip → AVAILABLE
+ */
+async function handleConnect(ctx, args) {
+    const target = args[0]?.trim();
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: `connect ${target || ''}`,
+    };
+    try {
+        const result = await v1Connect(target);
+        if (!result.ok) {
+            return {
+                events: [
+                    cmdEvent,
+                    {
+                        id: `err-${Date.now()}`,
+                        ts: Date.now(),
+                        tag: 'ERR',
+                        level: 'ERROR',
+                        msg: `Failed to connect: ${result.error.message}`,
+                    },
+                ],
+                uiStateUpdate: (prev) => ({
+                    ...prev,
+                    network: unavailable(result.error.message || 'Gateway unreachable', result.error.nextAction || 'Verify URL or run "system"'),
+                }),
+            };
+        }
+        // Success: network, capabilities, statusStrip → AVAILABLE
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `ok-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'NET',
+                    level: 'INFO',
+                    msg: `Connected to Gateway${target ? ` at ${target}` : ''}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                network: available({
+                    gateway: 'CONNECTED',
+                }),
+                capabilities: available({
+                    items: [], // TODO: load capabilities from gateway
+                }),
+                statusStrip: available({
+                    left: 'CONNECTED',
+                    right: target || result.data.gatewayUrl || 'Gateway',
+                }),
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Failed to connect: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                network: unavailable('Gateway unreachable', 'Verify URL or run "system"'),
+            }),
+        };
+    }
+}
+/**
+ * 5️⃣ start <agentId>
+ *
+ * Calls v1Adapters/runs.startRun(agentId)
+ * Updates posture → AVAILABLE (mode: RUNNING)
+ */
+async function handleStart(ctx, args) {
+    const agentId = args[0]?.trim();
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: `start ${agentId || ''}`,
+    };
+    if (!agentId) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: 'Agent ID required (usage: start <agentId>)',
+                },
+            ],
+        };
+    }
+    try {
+        const result = await startRun(agentId);
+        if (!result.ok) {
+            return {
+                events: [
+                    cmdEvent,
+                    {
+                        id: `err-${Date.now()}`,
+                        ts: Date.now(),
+                        tag: 'ERR',
+                        level: 'ERROR',
+                        msg: `Failed to start run: ${result.error.message}`,
+                    },
+                ],
+                uiStateUpdate: (prev) => ({
+                    ...prev,
+                    posture: unavailable(result.error.message || 'Run failed to start', result.error.nextAction || 'Run "runs list"'),
+                }),
+            };
+        }
+        // Success: posture → AVAILABLE (mode: RUNNING)
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `ok-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'RUN',
+                    level: 'INFO',
+                    msg: `Run started (id: ${result.data.id})`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                posture: available({
+                    mode: 'RUNNING',
+                }),
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Failed to start run: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                posture: unavailable('Run failed to start', 'Run "runs list"'),
+            }),
+        };
+    }
+}
+/**
+ * 6️⃣ runs list
+ *
+ * Calls v1Adapters/runs (needs listRuns function - TODO)
+ * Updates posture → AVAILABLE
+ */
+async function handleRuns(ctx, args) {
+    const subcommand = args[0]?.toLowerCase() || 'list';
+    if (subcommand === 'list') {
+        return handleRunsList(ctx, args.slice(1));
+    }
+    else {
+        return {
+            events: [{
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Unknown runs subcommand: ${subcommand} (try: list)`,
+                }],
+        };
+    }
+}
+async function handleRunsList(ctx, args) {
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: 'runs list',
+    };
+    try {
+        const result = await listRuns();
+        if (!result.ok) {
+            return {
+                events: [
+                    cmdEvent,
+                    {
+                        id: `err-${Date.now()}`,
+                        ts: Date.now(),
+                        tag: 'ERR',
+                        level: 'ERROR',
+                        msg: `Failed to list runs: ${result.error.message}`,
+                    },
+                ],
+                uiStateUpdate: (prev) => ({
+                    ...prev,
+                    posture: unavailable(result.error.message || 'Cannot fetch runs', result.error.nextAction || 'Run "connect" first'),
+                }),
+            };
+        }
+        const runs = result.data;
+        const count = runs.length;
+        // Success: posture → AVAILABLE
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `ok-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'RUN',
+                    level: 'INFO',
+                    msg: `${count} run${count === 1 ? '' : 's'} found`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                posture: available({
+                    mode: 'HUB',
+                }),
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `Failed to list runs: ${error.message || 'Unknown error'}`,
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                posture: unavailable('Cannot fetch runs', 'Run "connect" first'),
+            }),
+        };
+    }
+}
+/**
+ * 7️⃣ system
+ *
+ * Aggregates network state, config, agent count, run count
+ * Updates statusStrip → AVAILABLE
+ */
+async function handleSystem(ctx, args) {
+    const cmdEvent = {
+        id: `cmd-${Date.now()}`,
+        ts: Date.now(),
+        tag: 'CMD',
+        level: 'INFO',
+        msg: 'system',
+    };
+    try {
+        // Aggregate system state
+        const agentsResult = listAgents();
+        const configResult = loadConfig();
+        const connectionResult = await getConnectionState();
+        const agentCount = agentsResult.ok ? agentsResult.data.length : 0;
+        const connected = connectionResult.ok && connectionResult.data.connected;
+        const statusLeft = connected ? 'CONNECTED' : 'OFFLINE';
+        const statusRight = `Agents: ${agentCount}`;
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `ok-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'SYS',
+                    level: connected ? 'INFO' : 'WARN',
+                    msg: connected ? 'System healthy' : 'Partial connectivity',
+                },
+            ],
+            uiStateUpdate: (prev) => ({
+                ...prev,
+                statusStrip: available({
+                    left: statusLeft,
+                    right: statusRight,
+                }),
+            }),
+        };
+    }
+    catch (error) {
+        return {
+            events: [
+                cmdEvent,
+                {
+                    id: `err-${Date.now()}`,
+                    ts: Date.now(),
+                    tag: 'ERR',
+                    level: 'ERROR',
+                    msg: `System check failed: ${error.message || 'Unknown error'}`,
+                },
+            ],
+        };
+    }
+}
 //# sourceMappingURL=commandEngine.js.map