@roj-ai/cli 0.0.2

package/dist/commands/presets.js

@@ -0,0 +1,14 @@
+import { formatTable } from '../repl/formatter.js';
+import { unwrap } from '../unwrap.js';
+export async function presetsCommand(client, json) {
+    const { presets } = unwrap(await client.call('presets.list', {}));
+    if (json) {
+        console.log(JSON.stringify(presets, null, 2));
+        return;
+    }
+    if (presets.length === 0) {
+        console.log('No presets available.');
+        return;
+    }
+    console.log(formatTable(['ID', 'Name', 'Description'], presets.map(p => [p.id, p.name, p.description ?? ''])));
+}

package/dist/commands/sessions.d.ts

@@ -0,0 +1,6 @@
+import type { RpcClient } from '@roj-ai/shared/rpc';
+export declare function sessionsListCommand(client: RpcClient, status: 'active' | 'closed' | 'errored' | undefined, json: boolean): Promise<void>;
+export declare function sessionCreateCommand(client: RpcClient, presetId: string, json: boolean): Promise<void>;
+export declare function sessionGetCommand(client: RpcClient, sessionId: string, json: boolean): Promise<void>;
+export declare function sessionCloseCommand(client: RpcClient, sessionId: string, json: boolean): Promise<void>;
+//# sourceMappingURL=sessions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../src/commands/sessions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAQnD,wBAAsB,mBAAmB,CACxC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,EACnD,IAAI,EAAE,OAAO,GACX,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAS5G;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAa1G;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAS5G"}

package/dist/commands/sessions.js

@@ -0,0 +1,50 @@
+import { formatSessionInfo, formatTable } from '../repl/formatter.js';
+import { unwrap } from '../unwrap.js';
+function isSessionMetadata(data) {
+    return typeof data === 'object' && data !== null && 'sessionId' in data && 'presetId' in data;
+}
+export async function sessionsListCommand(client, status, json) {
+    const { sessions } = unwrap(await client.call('sessions.list', { status, limit: 50, order: 'desc' }));
+    if (json) {
+        console.log(JSON.stringify(sessions, null, 2));
+        return;
+    }
+    if (sessions.length === 0) {
+        console.log('No sessions found.');
+        return;
+    }
+    console.log(formatTable(['Session ID', 'Preset', 'Status', 'Created'], sessions.filter(isSessionMetadata).map(s => [
+        s.sessionId,
+        s.presetId,
+        s.status,
+        new Date(s.createdAt).toLocaleString(),
+    ])));
+}
+export async function sessionCreateCommand(client, presetId, json) {
+    const { sessionId } = unwrap(await client.call('sessions.create', { presetId }));
+    if (json) {
+        console.log(JSON.stringify({ sessionId }));
+        return;
+    }
+    console.log(`Session created: ${sessionId}`);
+}
+export async function sessionGetCommand(client, sessionId, json) {
+    const session = unwrap(await client.call('sessions.get', { sessionId }));
+    if (json) {
+        console.log(JSON.stringify(session, null, 2));
+        return;
+    }
+    console.log(formatSessionInfo(session));
+    console.log(`  Agents: ${session.agentCount}`);
+    if (session.closedAt) {
+        console.log(`  Closed: ${new Date(session.closedAt).toLocaleString()}`);
+    }
+}
+export async function sessionCloseCommand(client, sessionId, json) {
+    const result = unwrap(await client.call('sessions.close', { sessionId }));
+    if (json) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    console.log('Session closed.');
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":""}

package/dist/main.js

@@ -0,0 +1,277 @@
+import { SessionId } from '@roj-ai/shared';
+import { RpcError } from '@roj-ai/shared/rpc';
+import { createCliClient } from './client.js';
+import { answerCommand } from './commands/answer.js';
+import { agentCommand, agentsCommand, debugSendCommand, eventsCommand, llmCallCommand, llmCallsCommand, mailboxCommand, metricsCommand, presetAgentsCommand, spawnAgentCommand, timelineCommand, } from './commands/debug.js';
+import { messagesCommand, sendCommand } from './commands/messages.js';
+import { presetsCommand } from './commands/presets.js';
+import { sessionCloseCommand, sessionCreateCommand, sessionGetCommand, sessionsListCommand } from './commands/sessions.js';
+import { startRepl } from './repl/repl.js';
+const USAGE = `Usage:
+  roj-cli [options]                                  Start REPL
+  roj-cli <command> [args] [options]                  Non-interactive
+
+Options:
+  --url <url>     Server URL (default: http://localhost:2486, env: ROJ_URL)
+  --json          Output as JSON (non-interactive only)
+
+Commands:
+  presets                                                List available presets
+  sessions [--status active|closed|errored]              List sessions
+  session-create <presetId>                              Create new session
+  session-get <sessionId>                                Get session info
+  session-close <sessionId>                              Close session
+  messages <sessionId>                                   Get messages
+  send <sessionId> <message> [--wait]                    Send message
+  answer <sessionId> <questionId> <answer>               Answer agent question
+
+Debug commands:
+  events <sessionId> [--type <type>] [--agent <id>] [--limit N]   Show domain events
+  agents <sessionId>                                               Show agent tree
+  agent <sessionId> <agentId>                                      Show agent detail
+  mailbox <sessionId>                                              Show global mailbox
+  timeline <sessionId>                                             Show execution timeline
+  metrics <sessionId>                                              Show session metrics
+  llm-calls <sessionId> [--limit N]                                List LLM calls
+  llm-call <sessionId> <callId>                                    Show LLM call detail
+  preset-agents <sessionId>                                        Show spawnable agents
+  debug-send <sessionId> <agentId> <message> [--from <sender>]     Send debug message
+  spawn-agent <sessionId> <defName> <parentId> [--message <msg>]   Spawn agent manually`;
+function parseArgs(argv) {
+    // Skip bun and script path
+    const args = argv.slice(2);
+    let url = process.env.ROJ_URL ?? 'http://localhost:2486';
+    let json = false;
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--url') {
+            url = args[++i];
+        }
+        else if (arg === '--json') {
+            json = true;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            console.log(USAGE);
+            process.exit(0);
+        }
+        else if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            if (next && !next.startsWith('--')) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return {
+        url,
+        json,
+        command: positional[0] ?? null,
+        positional: positional.slice(1),
+        flags,
+    };
+}
+async function main() {
+    const parsed = parseArgs(process.argv);
+    const client = createCliClient(parsed.url);
+    // REPL mode if no command
+    if (!parsed.command) {
+        await startRepl(client, parsed.url);
+        return;
+    }
+    switch (parsed.command) {
+        case 'presets':
+            await presetsCommand(client, parsed.json);
+            break;
+        case 'sessions': {
+            const status = parsed.flags.status;
+            await sessionsListCommand(client, typeof status === 'string' ? status : undefined, parsed.json);
+            break;
+        }
+        case 'session-create': {
+            const presetId = parsed.positional[0];
+            if (!presetId) {
+                console.error('Usage: session-create <presetId>');
+                process.exit(1);
+            }
+            await sessionCreateCommand(client, presetId, parsed.json);
+            break;
+        }
+        case 'session-get': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: session-get <sessionId>');
+                process.exit(1);
+            }
+            await sessionGetCommand(client, sessionId, parsed.json);
+            break;
+        }
+        case 'session-close': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: session-close <sessionId>');
+                process.exit(1);
+            }
+            await sessionCloseCommand(client, sessionId, parsed.json);
+            break;
+        }
+        case 'messages': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: messages <sessionId>');
+                process.exit(1);
+            }
+            await messagesCommand(client, sessionId, parsed.json);
+            break;
+        }
+        case 'send': {
+            const sessionId = parsed.positional[0];
+            const message = parsed.positional.slice(1).join(' ');
+            if (!sessionId || !message) {
+                console.error('Usage: send <sessionId> <message> [--wait]');
+                process.exit(1);
+            }
+            const wait = parsed.flags.wait === true;
+            await sendCommand(client, parsed.url, sessionId, message, wait, parsed.json);
+            break;
+        }
+        case 'answer': {
+            const sessionId = parsed.positional[0];
+            const questionId = parsed.positional[1];
+            const answer = parsed.positional.slice(2).join(' ');
+            if (!sessionId || !questionId || !answer) {
+                console.error('Usage: answer <sessionId> <questionId> <answer>');
+                process.exit(1);
+            }
+            await answerCommand(client, sessionId, questionId, answer, parsed.json);
+            break;
+        }
+        // Debug commands
+        case 'events': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: events <sessionId> [--type <type>] [--agent <agentId>] [--limit N]');
+                process.exit(1);
+            }
+            await eventsCommand(client, sessionId, parsed.flags, parsed.json);
+            break;
+        }
+        case 'agents': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: agents <sessionId>');
+                process.exit(1);
+            }
+            await agentsCommand(client, sessionId, parsed.json);
+            break;
+        }
+        case 'agent': {
+            const sessionId = parsed.positional[0];
+            const agentId = parsed.positional[1];
+            if (!sessionId || !agentId) {
+                console.error('Usage: agent <sessionId> <agentId>');
+                process.exit(1);
+            }
+            await agentCommand(client, sessionId, agentId, parsed.json);
+            break;
+        }
+        case 'mailbox': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: mailbox <sessionId>');
+                process.exit(1);
+            }
+            await mailboxCommand(client, sessionId, parsed.json);
+            break;
+        }
+        case 'timeline': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: timeline <sessionId>');
+                process.exit(1);
+            }
+            await timelineCommand(client, sessionId, parsed.json);
+            break;
+        }
+        case 'metrics': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: metrics <sessionId>');
+                process.exit(1);
+            }
+            await metricsCommand(client, sessionId, parsed.json);
+            break;
+        }
+        case 'llm-calls': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: llm-calls <sessionId> [--limit N]');
+                process.exit(1);
+            }
+            await llmCallsCommand(client, sessionId, parsed.flags, parsed.json);
+            break;
+        }
+        case 'llm-call': {
+            const sessionId = parsed.positional[0];
+            const callId = parsed.positional[1];
+            if (!sessionId || !callId) {
+                console.error('Usage: llm-call <sessionId> <callId>');
+                process.exit(1);
+            }
+            await llmCallCommand(client, sessionId, callId, parsed.json);
+            break;
+        }
+        case 'preset-agents': {
+            const sessionId = parsed.positional[0];
+            if (!sessionId) {
+                console.error('Usage: preset-agents <sessionId>');
+                process.exit(1);
+            }
+            await presetAgentsCommand(client, SessionId(sessionId), parsed.json);
+            break;
+        }
+        case 'debug-send': {
+            const sessionId = parsed.positional[0];
+            const agentId = parsed.positional[1];
+            const message = parsed.positional.slice(2).join(' ');
+            if (!sessionId || !agentId || !message) {
+                console.error('Usage: debug-send <sessionId> <agentId> <message> [--from <sender>]');
+                process.exit(1);
+            }
+            await debugSendCommand(client, sessionId, agentId, message, parsed.flags, parsed.json);
+            break;
+        }
+        case 'spawn-agent': {
+            const sessionId = parsed.positional[0];
+            const definitionName = parsed.positional[1];
+            const parentId = parsed.positional[2];
+            if (!sessionId || !definitionName || !parentId) {
+                console.error('Usage: spawn-agent <sessionId> <definitionName> <parentId> [--message <msg>]');
+                process.exit(1);
+            }
+            await spawnAgentCommand(client, sessionId, definitionName, parentId, parsed.flags, parsed.json);
+            break;
+        }
+        default:
+            console.error(`Unknown command: ${parsed.command}`);
+            console.error(USAGE);
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    if (error instanceof RpcError) {
+        console.error(`RPC Error [${error.error.type}]: ${error.error.message}`);
+    }
+    else {
+        console.error(error instanceof Error ? error.message : String(error));
+    }
+    process.exit(1);
+});

package/dist/repl/formatter.d.ts

@@ -0,0 +1,16 @@
+import type { AskUserInputTypeSchema } from '@roj-ai/sdk';
+import type { ChatMessage } from '@roj-ai/shared/rpc';
+export declare function formatAgentMessage(content: string): string;
+export declare function formatUserMessage(content: string): string;
+export declare function formatStatus(status: string): string;
+export declare function formatError(message: string): string;
+export declare function formatQuestion(question: string, inputType: AskUserInputTypeSchema): string;
+export declare function formatChatMessage(msg: ChatMessage): string;
+export declare function formatSessionInfo(session: {
+    sessionId: string;
+    presetId: string;
+    status: string;
+    createdAt: number;
+}): string;
+export declare function formatTable(headers: string[], rows: string[][]): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/repl/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/repl/formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAYrD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,sBAAsB,GAAG,MAAM,CAuB1F;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAW1D;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAG7H;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAWvE"}

package/dist/repl/formatter.js

@@ -0,0 +1,72 @@
+// ANSI color codes
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const MAGENTA = '\x1b[35m';
+export function formatAgentMessage(content) {
+    return `${CYAN}${BOLD}Agent:${RESET} ${content}`;
+}
+export function formatUserMessage(content) {
+    return `${GREEN}${BOLD}You:${RESET} ${content}`;
+}
+export function formatStatus(status) {
+    return `${DIM}[${status}]${RESET}`;
+}
+export function formatError(message) {
+    return `${RED}Error: ${message}${RESET}`;
+}
+export function formatQuestion(question, inputType) {
+    const lines = [`${YELLOW}${BOLD}Question:${RESET} ${question}`];
+    if (inputType.type === 'single_choice' || inputType.type === 'multi_choice') {
+        for (let i = 0; i < inputType.options.length; i++) {
+            const opt = inputType.options[i];
+            const desc = opt.description ? ` - ${opt.description}` : '';
+            lines.push(`  ${MAGENTA}${i + 1})${RESET} ${opt.label}${DIM}${desc}${RESET}`);
+        }
+        if (inputType.type === 'single_choice') {
+            lines.push(`${DIM}Enter number to select:${RESET}`);
+        }
+        else {
+            lines.push(`${DIM}Enter numbers separated by commas:${RESET}`);
+        }
+    }
+    else if (inputType.type === 'confirm') {
+        const confirmLabel = inputType.confirmLabel ?? 'yes';
+        const cancelLabel = inputType.cancelLabel ?? 'no';
+        lines.push(`${DIM}(${confirmLabel}/${cancelLabel}):${RESET}`);
+    }
+    else if (inputType.type === 'rating') {
+        lines.push(`${DIM}Enter a number from ${inputType.min} to ${inputType.max}:${RESET}`);
+    }
+    return lines.join('\n');
+}
+export function formatChatMessage(msg) {
+    switch (msg.type) {
+        case 'user_message':
+            return formatUserMessage(msg.content);
+        case 'agent_message':
+            return formatAgentMessage(msg.content);
+        case 'ask_user': {
+            const answered = msg.answered ? `${DIM} (answered: ${JSON.stringify(msg.answer)})${RESET}` : '';
+            return formatQuestion(msg.question, msg.inputType) + answered;
+        }
+    }
+}
+export function formatSessionInfo(session) {
+    const date = new Date(session.createdAt).toLocaleString();
+    return `${BOLD}${session.sessionId}${RESET} ${DIM}[${session.presetId}]${RESET} ${session.status} ${DIM}${date}${RESET}`;
+}
+export function formatTable(headers, rows) {
+    const colWidths = headers.map((h, i) => {
+        const maxDataWidth = rows.reduce((max, row) => Math.max(max, (row[i] ?? '').length), 0);
+        return Math.max(h.length, maxDataWidth);
+    });
+    const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ');
+    const separator = colWidths.map(w => '─'.repeat(w)).join('──');
+    const dataLines = rows.map(row => row.map((cell, i) => (cell ?? '').padEnd(colWidths[i])).join('  '));
+    return [headerLine, separator, ...dataLines].join('\n');
+}

package/dist/repl/repl.d.ts

@@ -0,0 +1,3 @@
+import type { RpcClient } from '@roj-ai/shared/rpc';
+export declare function startRepl(client: RpcClient, baseUrl: string): Promise<void>;
+//# sourceMappingURL=repl.d.ts.map

package/dist/repl/repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.ts","sourceRoot":"","sources":["../../src/repl/repl.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAUnD,wBAAsB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA0HjF"}

package/dist/repl/repl.js

@@ -0,0 +1,212 @@
+import { AgentId, ChatMessageId } from '@roj-ai/shared';
+function isChatMessage(msg) {
+    return typeof msg === 'object' && msg !== null && 'type' in msg && 'timestamp' in msg;
+}
+import * as readline from 'node:readline';
+import { connectWebSocket } from '../client.js';
+import { unwrap } from '../unwrap.js';
+import { formatAgentMessage, formatChatMessage, formatError, formatQuestion, formatStatus } from './formatter.js';
+import { createNewSession, pickSession } from './session-picker.js';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+export async function startRepl(client, baseUrl) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log(`${DIM}Connected to ${baseUrl}${RESET}`);
+    console.log(`${DIM}Commands: /quit, /sessions, /new, /messages, /help${RESET}`);
+    let sessionId = await pickSession(client, rl);
+    let entryAgentId = await resolveEntryAgentId(client, sessionId);
+    await loadAndDisplayMessages(client, sessionId);
+    let pendingQuestion = null;
+    const handlers = {
+        agentMessage: (payload) => {
+            if (typeof payload !== 'object' || payload === null)
+                return;
+            const input = payload;
+            if (typeof input.content !== 'string')
+                return;
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            console.log(formatAgentMessage(input.content));
+            rl.prompt();
+        },
+        askUser: (payload) => {
+            if (typeof payload !== 'object' || payload === null)
+                return;
+            const input = payload;
+            if (typeof input.questionId !== 'string' || typeof input.question !== 'string')
+                return;
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            console.log(formatQuestion(input.question, input.inputType));
+            pendingQuestion = { questionId: input.questionId, inputType: input.inputType };
+            rl.prompt();
+        },
+        agentStatus: (payload) => {
+            if (typeof payload !== 'object' || payload === null)
+                return;
+            const input = payload;
+            if (typeof input.status !== 'string')
+                return;
+            const statusLabels = {
+                idle: 'Agent idle',
+                thinking: 'Agent thinking...',
+                responding: 'Agent responding...',
+                waiting_for_user: 'Waiting for your input',
+                error: 'Agent error',
+            };
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            console.log(formatStatus(statusLabels[input.status] ?? input.status));
+            rl.prompt();
+        },
+        error: (payload) => {
+            if (typeof payload !== 'object' || payload === null)
+                return;
+            const input = payload;
+            if (typeof input.message !== 'string')
+                return;
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            console.log(formatError(input.message));
+            rl.prompt();
+        },
+    };
+    let connection = connectWebSocket(baseUrl, sessionId, handlers);
+    await connection.connect();
+    rl.setPrompt('> ');
+    rl.prompt();
+    rl.on('line', async (line) => {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        if (input.startsWith('/')) {
+            const handled = await handleSlashCommand(input, client, baseUrl, rl, sessionId, connection);
+            if (handled === 'quit') {
+                await connection.disconnect();
+                rl.close();
+                return;
+            }
+            if (handled !== false) {
+                // Session switch
+                await connection.disconnect();
+                sessionId = handled;
+                entryAgentId = await resolveEntryAgentId(client, sessionId);
+                connection = connectWebSocket(baseUrl, sessionId, handlers);
+                await connection.connect();
+                await loadAndDisplayMessages(client, sessionId);
+            }
+            rl.prompt();
+            return;
+        }
+        // Handle pending question answer
+        if (pendingQuestion && entryAgentId) {
+            const answer = parseAnswer(input, pendingQuestion.inputType);
+            unwrap(await client.call('user-chat.answerQuestion', {
+                sessionId,
+                agentId: AgentId(entryAgentId),
+                questionId: ChatMessageId(pendingQuestion.questionId),
+                answer,
+            }));
+            pendingQuestion = null;
+            rl.prompt();
+            return;
+        }
+        // Send message
+        if (entryAgentId) {
+            unwrap(await client.call('user-chat.sendMessage', { sessionId, agentId: AgentId(entryAgentId), content: input }));
+        }
+        rl.prompt();
+    });
+    rl.on('close', async () => {
+        await connection.disconnect();
+        process.exit(0);
+    });
+}
+async function resolveEntryAgentId(client, sessionId) {
+    const session = unwrap(await client.call('sessions.get', { sessionId }));
+    return session.entryAgentId;
+}
+async function loadAndDisplayMessages(client, sessionId) {
+    const { messages: rawMessages } = unwrap(await client.call('user-chat.getMessages', { sessionId }));
+    const messages = rawMessages.filter(isChatMessage);
+    if (messages.length > 0) {
+        console.log();
+        console.log(`${DIM}--- Message history ---${RESET}`);
+        for (const msg of messages) {
+            console.log(formatChatMessage(msg));
+            console.log();
+        }
+        console.log(`${DIM}--- End of history ---${RESET}`);
+        console.log();
+    }
+}
+async function handleSlashCommand(input, client, _baseUrl, rl, currentSessionId, _connection) {
+    const [cmd] = input.split(/\s+/);
+    switch (cmd) {
+        case '/quit':
+        case '/exit':
+        case '/q':
+            return 'quit';
+        case '/sessions': {
+            const newSessionId = await pickSession(client, rl);
+            if (newSessionId !== currentSessionId) {
+                return newSessionId;
+            }
+            return false;
+        }
+        case '/new': {
+            const newSessionId = await createNewSession(client, rl);
+            return newSessionId;
+        }
+        case '/messages': {
+            await loadAndDisplayMessages(client, currentSessionId);
+            return false;
+        }
+        case '/help':
+            console.log(`${DIM}Commands:${RESET}`);
+            console.log(`  /quit, /exit, /q  - Exit the REPL`);
+            console.log(`  /sessions         - Switch to another session`);
+            console.log(`  /new              - Create a new session`);
+            console.log(`  /messages         - Show message history`);
+            console.log(`  /help             - Show this help`);
+            return false;
+        default:
+            console.log(`Unknown command: ${cmd}. Type /help for available commands.`);
+            return false;
+    }
+}
+function parseAnswer(input, inputType) {
+    switch (inputType.type) {
+        case 'text':
+            return input;
+        case 'single_choice': {
+            const index = parseInt(input, 10) - 1;
+            if (index >= 0 && index < inputType.options.length) {
+                return inputType.options[index].value;
+            }
+            return input;
+        }
+        case 'multi_choice': {
+            const indices = input.split(',').map(s => parseInt(s.trim(), 10) - 1);
+            return indices
+                .filter(i => i >= 0 && i < inputType.options.length)
+                .map(i => inputType.options[i].value);
+        }
+        case 'confirm': {
+            const lower = input.toLowerCase();
+            return lower === 'y' || lower === 'yes' || lower === '1' || lower === 'true';
+        }
+        case 'rating': {
+            const num = parseInt(input, 10);
+            if (num >= inputType.min && num <= inputType.max) {
+                return num;
+            }
+            return parseInt(input, 10);
+        }
+    }
+}