recoder-code 2.5.2 → 2.5.3

package/dist/src/ui/commands/workflowCommands.js

@@ -0,0 +1,291 @@
+/**
+ * Workflow & utility CLI commands for Recoder Code
+ *
+ * Slash commands:
+ *   /workflow list                - List workflows for current project
+ *   /workflow run <id>            - Execute a workflow
+ *   /workflow status <exec-id>    - Check execution status
+ *   /analytics                    - Show agent analytics summary
+ *   /cost                         - Show cost summary
+ *   /whoami                       - Show current user info
+ */
+import { CommandKind } from './types.js';
+import { RecoderAuthService } from '../../services/RecoderAuthService.js';
+const BACKEND_URL = process.env['RECODER_BACKEND_URL'] || process.env['DOCKER_BACKEND_URL'] || 'https://api.recoder.xyz';
+const authService = new RecoderAuthService();
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function authenticatedGet(path) {
+    const token = await authService.getAccessToken();
+    if (!token) {
+        throw new Error('Not authenticated. Run /recoder-login first.');
+    }
+    return fetch(`${BACKEND_URL}${path}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+    });
+}
+async function authenticatedPost(path, body) {
+    const token = await authService.getAccessToken();
+    if (!token) {
+        throw new Error('Not authenticated. Run /recoder-login first.');
+    }
+    return fetch(`${BACKEND_URL}${path}`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : 'Unknown error';
+}
+// ---------------------------------------------------------------------------
+// /workflow
+// ---------------------------------------------------------------------------
+export const workflowCommand = {
+    name: 'workflow',
+    description: 'Manage and run workflows',
+    kind: CommandKind.BUILT_IN,
+    subCommands: [
+        // /workflow list
+        {
+            name: 'list',
+            description: 'List workflows for an agent (e.g., /workflow list <agent-id>)',
+            kind: CommandKind.BUILT_IN,
+            action: async (_context, args) => {
+                const agentId = args?.trim();
+                if (!agentId) {
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: 'Usage: /workflow list <agent-id>',
+                    };
+                }
+                try {
+                    const res = await authenticatedGet(`/api/workflows/agent/${encodeURIComponent(agentId)}`);
+                    if (!res.ok) {
+                        return { type: 'message', messageType: 'error', content: `Failed (${res.status}): ${await res.text()}` };
+                    }
+                    const workflows = await res.json();
+                    const list = Array.isArray(workflows) ? workflows : workflows.data || [];
+                    if (list.length === 0) {
+                        return { type: 'message', messageType: 'info', content: 'No workflows found for this agent.' };
+                    }
+                    const lines = [
+                        '┌──────────────────────────────────────────────────┐',
+                        '│  Workflows                                        │',
+                        '├──────────────────────────────────────────────────┤',
+                    ];
+                    for (const wf of list) {
+                        lines.push(`│  ${(wf.name || 'Untitled').padEnd(47)}│`);
+                        lines.push(`│    ID: ${String(wf.id).padEnd(41)}│`);
+                        lines.push(`│    Status: ${String(wf.status || 'draft').padEnd(37)}│`);
+                        lines.push('│                                                  │');
+                    }
+                    lines.push(`├──────────────────────────────────────────────────┤`);
+                    lines.push(`│  Total: ${String(list.length).padEnd(40)}│`);
+                    lines.push('│  Run with: /workflow run <id>                    │');
+                    lines.push('└──────────────────────────────────────────────────┘');
+                    return { type: 'message', messageType: 'info', content: lines.join('\n') };
+                }
+                catch (err) {
+                    return { type: 'message', messageType: 'error', content: `Error listing workflows: ${errorMessage(err)}` };
+                }
+            },
+        },
+        // /workflow run <id>
+        {
+            name: 'run',
+            description: 'Execute a workflow (e.g., /workflow run <workflow-id>)',
+            kind: CommandKind.BUILT_IN,
+            action: async (_context, args) => {
+                const workflowId = args?.trim();
+                if (!workflowId) {
+                    return { type: 'message', messageType: 'info', content: 'Usage: /workflow run <workflow-id>' };
+                }
+                try {
+                    const res = await authenticatedPost(`/api/workflows/${encodeURIComponent(workflowId)}/execute`);
+                    if (!res.ok) {
+                        return { type: 'message', messageType: 'error', content: `Failed (${res.status}): ${await res.text()}` };
+                    }
+                    const execution = await res.json();
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: [
+                            '┌──────────────────────────────────────────────────┐',
+                            '│  Workflow Execution Started                       │',
+                            '├──────────────────────────────────────────────────┤',
+                            `│  Execution ID: ${String(execution.id || 'unknown').padEnd(33)}│`,
+                            `│  Status:       ${String(execution.status || 'pending').padEnd(33)}│`,
+                            '│                                                  │',
+                            '│  Check progress: /workflow status <exec-id>      │',
+                            '└──────────────────────────────────────────────────┘',
+                        ].join('\n'),
+                    };
+                }
+                catch (err) {
+                    return { type: 'message', messageType: 'error', content: `Error executing workflow: ${errorMessage(err)}` };
+                }
+            },
+        },
+        // /workflow status <execution-id>
+        {
+            name: 'status',
+            description: 'Check execution status (e.g., /workflow status <execution-id>)',
+            kind: CommandKind.BUILT_IN,
+            action: async (_context, args) => {
+                const executionId = args?.trim();
+                if (!executionId) {
+                    return { type: 'message', messageType: 'info', content: 'Usage: /workflow status <execution-id>' };
+                }
+                try {
+                    const res = await authenticatedGet(`/api/workflows/executions/${encodeURIComponent(executionId)}`);
+                    if (!res.ok) {
+                        return { type: 'message', messageType: 'error', content: `Failed (${res.status}): ${await res.text()}` };
+                    }
+                    const exec = await res.json();
+                    const duration = exec.duration_seconds != null ? `${exec.duration_seconds}s` : 'n/a';
+                    const cost = exec.total_cost != null ? `$${Number(exec.total_cost).toFixed(4)}` : 'n/a';
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: [
+                            '┌──────────────────────────────────────────────────┐',
+                            '│  Execution Status                                 │',
+                            '├──────────────────────────────────────────────────┤',
+                            `│  ID:       ${String(exec.id).padEnd(37)}│`,
+                            `│  Status:   ${String(exec.status).padEnd(37)}│`,
+                            `│  Duration: ${duration.padEnd(37)}│`,
+                            `│  Cost:     ${cost.padEnd(37)}│`,
+                            `│  Started:  ${String(exec.started_at || 'n/a').substring(0, 37).padEnd(37)}│`,
+                            '└──────────────────────────────────────────────────┘',
+                        ].join('\n'),
+                    };
+                }
+                catch (err) {
+                    return { type: 'message', messageType: 'error', content: `Error fetching status: ${errorMessage(err)}` };
+                }
+            },
+        },
+    ],
+    // Default: show help
+    action: async () => ({
+        type: 'message',
+        messageType: 'info',
+        content: [
+            'Workflow Commands',
+            '',
+            '  /workflow list <agent-id>         List workflows for an agent',
+            '  /workflow run <workflow-id>        Execute a workflow',
+            '  /workflow status <execution-id>   Check execution status',
+        ].join('\n'),
+    }),
+};
+// ---------------------------------------------------------------------------
+// /analytics
+// ---------------------------------------------------------------------------
+export const analyticsCommand = {
+    name: 'analytics',
+    description: 'Show agent analytics summary',
+    kind: CommandKind.BUILT_IN,
+    action: async () => {
+        try {
+            const res = await authenticatedGet('/api/analytics/summary');
+            if (!res.ok) {
+                return { type: 'message', messageType: 'error', content: `Failed (${res.status}): ${await res.text()}` };
+            }
+            const data = await res.json();
+            const summary = data.data || data;
+            const lines = [
+                '┌──────────────────────────────────────────────────┐',
+                '│  Agent Analytics Summary                          │',
+                '├──────────────────────────────────────────────────┤',
+                `│  Total runs:       ${String(summary.total_runs ?? 'n/a').padEnd(29)}│`,
+                `│  Successful:       ${String(summary.successful_runs ?? 'n/a').padEnd(29)}│`,
+                `│  Failed:           ${String(summary.failed_runs ?? 'n/a').padEnd(29)}│`,
+                `│  Avg duration:     ${String(summary.avg_duration ? `${summary.avg_duration}s` : 'n/a').padEnd(29)}│`,
+                `│  Total cost:       ${String(summary.total_cost ? `$${Number(summary.total_cost).toFixed(4)}` : 'n/a').padEnd(29)}│`,
+                `│  Active agents:    ${String(summary.active_agents ?? 'n/a').padEnd(29)}│`,
+                '└──────────────────────────────────────────────────┘',
+            ];
+            return { type: 'message', messageType: 'info', content: lines.join('\n') };
+        }
+        catch (err) {
+            return { type: 'message', messageType: 'error', content: `Error fetching analytics: ${errorMessage(err)}` };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// /cost
+// ---------------------------------------------------------------------------
+export const costCommand = {
+    name: 'cost',
+    description: 'Show cost summary for the current billing period',
+    kind: CommandKind.BUILT_IN,
+    action: async () => {
+        try {
+            const res = await authenticatedGet('/api/billing/usage');
+            if (!res.ok) {
+                return { type: 'message', messageType: 'error', content: `Failed (${res.status}): ${await res.text()}` };
+            }
+            const data = await res.json();
+            const usage = data.data || data;
+            const lines = [
+                '┌──────────────────────────────────────────────────┐',
+                '│  Cost Summary                                     │',
+                '├──────────────────────────────────────────────────┤',
+                `│  Period:           ${String(usage.period || 'current').padEnd(29)}│`,
+                `│  Total spent:      ${String(usage.total_cost ? `$${Number(usage.total_cost).toFixed(4)}` : '$0.00').padEnd(29)}│`,
+                `│  Budget limit:     ${String(usage.budget_limit ? `$${Number(usage.budget_limit).toFixed(2)}` : 'none').padEnd(29)}│`,
+                `│  Budget remaining: ${String(usage.budget_remaining ? `$${Number(usage.budget_remaining).toFixed(2)}` : 'n/a').padEnd(29)}│`,
+                `│  API calls:        ${String(usage.api_call_count ?? 'n/a').padEnd(29)}│`,
+                `│  Tokens used:      ${String(usage.total_tokens ?? 'n/a').padEnd(29)}│`,
+                '└──────────────────────────────────────────────────┘',
+            ];
+            return { type: 'message', messageType: 'info', content: lines.join('\n') };
+        }
+        catch (err) {
+            return { type: 'message', messageType: 'error', content: `Error fetching cost data: ${errorMessage(err)}` };
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// /whoami
+// ---------------------------------------------------------------------------
+export const whoamiCommand = {
+    name: 'whoami',
+    description: 'Show current authenticated user info',
+    kind: CommandKind.BUILT_IN,
+    action: async () => {
+        try {
+            const res = await authenticatedGet('/api/user/profile');
+            if (!res.ok) {
+                return { type: 'message', messageType: 'error', content: `Failed (${res.status}): ${await res.text()}` };
+            }
+            const data = await res.json();
+            const user = data.data || data;
+            const lines = [
+                '┌──────────────────────────────────────────────────┐',
+                '│  Current User                                     │',
+                '├──────────────────────────────────────────────────┤',
+                `│  Name:   ${String(user.name || user.display_name || 'n/a').padEnd(39)}│`,
+                `│  Email:  ${String(user.email || 'n/a').padEnd(39)}│`,
+                `│  Plan:   ${String(user.plan || user.tier || 'free').padEnd(39)}│`,
+                `│  ID:     ${String(user.id || 'n/a').substring(0, 39).padEnd(39)}│`,
+                '└──────────────────────────────────────────────────┘',
+            ];
+            return { type: 'message', messageType: 'info', content: lines.join('\n') };
+        }
+        catch (err) {
+            return { type: 'message', messageType: 'error', content: `Error fetching user info: ${errorMessage(err)}` };
+        }
+    },
+};

package/dist/src/ui/commands/workspaceCommand.d.ts

@@ -0,0 +1,11 @@
+/**
+ * /workspace slash command - Manage A2A workspace connections
+ *
+ * Subcommands:
+ *   /workspace list    - List available workspaces
+ *   /workspace join <id> - Connect to a workspace via AgentBridgeService
+ *   /workspace leave   - Disconnect from current workspace
+ *   /workspace status  - Show connection status and online agents
+ */
+import type { SlashCommand } from './types.js';
+export declare const workspaceCommand: SlashCommand;

package/dist/src/ui/commands/workspaceCommand.js

@@ -0,0 +1,329 @@
+/**
+ * /workspace slash command - Manage A2A workspace connections
+ *
+ * Subcommands:
+ *   /workspace list    - List available workspaces
+ *   /workspace join <id> - Connect to a workspace via AgentBridgeService
+ *   /workspace leave   - Disconnect from current workspace
+ *   /workspace status  - Show connection status and online agents
+ */
+import { CommandKind } from './types.js';
+import { RecoderAuthService } from '../../services/RecoderAuthService.js';
+import { AgentBridgeService } from '../../services/AgentBridgeService.js';
+const DOCKER_BACKEND_URL = process.env['DOCKER_BACKEND_URL'] || 'http://localhost:3100';
+// Singleton instances
+const authService = new RecoderAuthService();
+let bridgeInstance = null;
+function getBridge() {
+    if (!bridgeInstance) {
+        bridgeInstance = new AgentBridgeService(() => authService.getAccessToken());
+    }
+    return bridgeInstance;
+}
+export const workspaceCommand = {
+    name: 'workspace',
+    description: 'Manage A2A workspace connections',
+    kind: CommandKind.BUILT_IN,
+    subCommands: [
+        // -----------------------------------------------------------------------
+        // /workspace list
+        // -----------------------------------------------------------------------
+        {
+            name: 'list',
+            description: 'List available workspaces',
+            kind: CommandKind.BUILT_IN,
+            action: async () => {
+                const token = await authService.getAccessToken();
+                if (!token) {
+                    return {
+                        type: 'message',
+                        messageType: 'error',
+                        content: 'Not authenticated. Please run /recoder-login first.',
+                    };
+                }
+                try {
+                    const response = await fetch(`${DOCKER_BACKEND_URL}/api/a2a/workspaces`, {
+                        method: 'GET',
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json',
+                        },
+                    });
+                    if (!response.ok) {
+                        const errText = await response.text().catch(() => 'Unknown error');
+                        return {
+                            type: 'message',
+                            messageType: 'error',
+                            content: `Failed to fetch workspaces (${response.status}): ${errText}`,
+                        };
+                    }
+                    const data = await response.json();
+                    const workspaces = data.workspaces || data.data || data || [];
+                    if (!Array.isArray(workspaces) || workspaces.length === 0) {
+                        return {
+                            type: 'message',
+                            messageType: 'info',
+                            content: [
+                                '┌────────────────────────────────────────────────┐',
+                                '│  A2A Workspaces                                │',
+                                '├────────────────────────────────────────────────┤',
+                                '│  No workspaces found.                          │',
+                                '│                                                │',
+                                '│  Create one from the recoder.xyz dashboard     │',
+                                '│  or via the backend API.                       │',
+                                '└────────────────────────────────────────────────┘',
+                            ].join('\n'),
+                        };
+                    }
+                    const lines = [
+                        '┌────────────────────────────────────────────────┐',
+                        '│  A2A Workspaces                                │',
+                        '├────────────────────────────────────────────────┤',
+                    ];
+                    for (const ws of workspaces) {
+                        const agents = ws.agentCount !== undefined ? `${ws.agentCount} agents` : '';
+                        const channels = ws.channelCount !== undefined ? `${ws.channelCount} channels` : '';
+                        const meta = [agents, channels].filter(Boolean).join(', ');
+                        lines.push(`│  ${ws.name.padEnd(45)}│`);
+                        lines.push(`│    ID: ${ws.id.padEnd(39)}│`);
+                        if (ws.description) {
+                            lines.push(`│    ${ws.description.substring(0, 43).padEnd(45)}│`);
+                        }
+                        if (meta) {
+                            lines.push(`│    ${meta.padEnd(45)}│`);
+                        }
+                        lines.push('│                                                │');
+                    }
+                    lines.push('├────────────────────────────────────────────────┤');
+                    lines.push(`│  Total: ${String(workspaces.length).padEnd(38)}│`);
+                    lines.push('│  Join with: /workspace join <id>               │');
+                    lines.push('└────────────────────────────────────────────────┘');
+                    return { type: 'message', messageType: 'info', content: lines.join('\n') };
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : 'Unknown error';
+                    return {
+                        type: 'message',
+                        messageType: 'error',
+                        content: `Failed to list workspaces: ${msg}`,
+                    };
+                }
+            },
+        },
+        // -----------------------------------------------------------------------
+        // /workspace join <id>
+        // -----------------------------------------------------------------------
+        {
+            name: 'join',
+            description: 'Connect to a workspace (e.g., /workspace join <workspace-id>)',
+            kind: CommandKind.BUILT_IN,
+            action: async (_context, args) => {
+                if (!args?.trim()) {
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: [
+                            'Join Workspace',
+                            '',
+                            'Usage: /workspace join <workspace-id>',
+                            '',
+                            'Run /workspace list to see available workspace IDs.',
+                        ].join('\n'),
+                    };
+                }
+                const workspaceId = args.trim();
+                const bridge = getBridge();
+                if (bridge.isConnected() && bridge.getWorkspaceId() === workspaceId) {
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: `Already connected to workspace: ${workspaceId}`,
+                    };
+                }
+                // Disconnect from any existing workspace first
+                if (bridge.isConnected()) {
+                    bridge.disconnect();
+                }
+                try {
+                    await bridge.connect(workspaceId, ['code', 'review', 'test']);
+                    if (bridge.isConnected()) {
+                        return {
+                            type: 'message',
+                            messageType: 'info',
+                            content: [
+                                '┌────────────────────────────────────────────────┐',
+                                '│  Workspace Connected                           │',
+                                '├────────────────────────────────────────────────┤',
+                                `│  Workspace: ${workspaceId.substring(0, 35).padEnd(35)}│`,
+                                `│  Agent ID:  ${bridge.getAgentId().substring(0, 35).padEnd(35)}│`,
+                                '│  Status:    Online                             │',
+                                '├────────────────────────────────────────────────┤',
+                                '│  You will receive task assignments in          │',
+                                '│  real-time from the workspace coordinator.     │',
+                                '│                                                │',
+                                '│  /workspace status  - Check connection         │',
+                                '│  /workspace leave   - Disconnect               │',
+                                '└────────────────────────────────────────────────┘',
+                            ].join('\n'),
+                        };
+                    }
+                    else {
+                        return {
+                            type: 'message',
+                            messageType: 'error',
+                            content: [
+                                'Failed to connect to workspace.',
+                                '',
+                                'Possible reasons:',
+                                '  - docker-backend is not running',
+                                '  - Workspace ID does not exist',
+                                '  - Authentication token is invalid',
+                                '',
+                                'Check your connection and try again.',
+                            ].join('\n'),
+                        };
+                    }
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : 'Unknown error';
+                    return {
+                        type: 'message',
+                        messageType: 'error',
+                        content: `Failed to join workspace: ${msg}`,
+                    };
+                }
+            },
+        },
+        // -----------------------------------------------------------------------
+        // /workspace leave
+        // -----------------------------------------------------------------------
+        {
+            name: 'leave',
+            description: 'Disconnect from current workspace',
+            kind: CommandKind.BUILT_IN,
+            action: async () => {
+                const bridge = getBridge();
+                if (!bridge.isConnected()) {
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: 'Not connected to any workspace.',
+                    };
+                }
+                const workspaceId = bridge.getWorkspaceId() || 'unknown';
+                bridge.disconnect();
+                return {
+                    type: 'message',
+                    messageType: 'info',
+                    content: [
+                        '┌────────────────────────────────────────────────┐',
+                        '│  Workspace Disconnected                        │',
+                        '├────────────────────────────────────────────────┤',
+                        `│  Left: ${workspaceId.substring(0, 40).padEnd(40)}│`,
+                        '│  Status: Offline                               │',
+                        '│                                                │',
+                        '│  Reconnect with: /workspace join <id>          │',
+                        '└────────────────────────────────────────────────┘',
+                    ].join('\n'),
+                };
+            },
+        },
+        // -----------------------------------------------------------------------
+        // /workspace status
+        // -----------------------------------------------------------------------
+        {
+            name: 'status',
+            description: 'Show current connection status and online agents',
+            kind: CommandKind.BUILT_IN,
+            action: async () => {
+                const bridge = getBridge();
+                if (!bridge.isConnected()) {
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: [
+                            '┌────────────────────────────────────────────────┐',
+                            '│  Workspace Status                              │',
+                            '├────────────────────────────────────────────────┤',
+                            '│  Status:    Disconnected                       │',
+                            `│  Agent ID:  ${bridge.getAgentId().substring(0, 35).padEnd(35)}│`,
+                            '│                                                │',
+                            '│  Connect with: /workspace join <id>            │',
+                            '└────────────────────────────────────────────────┘',
+                        ].join('\n'),
+                    };
+                }
+                const workspaceId = bridge.getWorkspaceId() || 'none';
+                const lines = [
+                    '┌────────────────────────────────────────────────┐',
+                    '│  Workspace Status                              │',
+                    '├────────────────────────────────────────────────┤',
+                    '│  Status:    Connected                          │',
+                    `│  Workspace: ${workspaceId.substring(0, 35).padEnd(35)}│`,
+                    `│  Agent ID:  ${bridge.getAgentId().substring(0, 35).padEnd(35)}│`,
+                ];
+                // Try to fetch online agents from the backend
+                const token = await authService.getAccessToken();
+                if (token) {
+                    try {
+                        const response = await fetch(`${DOCKER_BACKEND_URL}/api/a2a/workspaces/${encodeURIComponent(workspaceId)}/agents`, {
+                            method: 'GET',
+                            headers: {
+                                'Authorization': `Bearer ${token}`,
+                                'Content-Type': 'application/json',
+                            },
+                        });
+                        if (response.ok) {
+                            const data = await response.json();
+                            const agents = data.agents || data.data || [];
+                            if (agents.length > 0) {
+                                lines.push('├────────────────────────────────────────────────┤');
+                                lines.push(`│  Online Agents (${String(agents.length).padEnd(30)}│`);
+                                lines.push('│                                                │');
+                                for (const agent of agents) {
+                                    const local = agent.isLocal ? ' (local)' : '';
+                                    const caps = agent.capabilities.length > 0
+                                        ? ` [${agent.capabilities.join(', ')}]`
+                                        : '';
+                                    const label = `${agent.agentId}${local}${caps}`;
+                                    lines.push(`│    ${label.substring(0, 44).padEnd(44)}│`);
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Silently skip agent listing on error
+                    }
+                }
+                lines.push('├────────────────────────────────────────────────┤');
+                lines.push('│  /workspace leave  - Disconnect                │');
+                lines.push('└────────────────────────────────────────────────┘');
+                return { type: 'message', messageType: 'info', content: lines.join('\n') };
+            },
+        },
+    ],
+    // -------------------------------------------------------------------------
+    // Default action (no subcommand)
+    // -------------------------------------------------------------------------
+    action: async () => {
+        const bridge = getBridge();
+        const connected = bridge.isConnected();
+        const wsId = bridge.getWorkspaceId();
+        const statusLine = connected
+            ? `Connected to: ${wsId}`
+            : 'Disconnected';
+        return {
+            type: 'message',
+            messageType: 'info',
+            content: [
+                `A2A Workspace (${statusLine})`,
+                '',
+                'Commands:',
+                '  /workspace list       - List available workspaces',
+                '  /workspace join <id>  - Connect to a workspace',
+                '  /workspace leave      - Disconnect from workspace',
+                '  /workspace status     - Show connection status',
+            ].join('\n'),
+        };
+    },
+};