@fluxra-ai/fluxra-cli 0.1.0

package/dist/cli/commands/chat/index.js

@@ -0,0 +1,1201 @@
+import { resolveProfile } from '../../helpers.js';
+import { openProfileDatabases, closeDatabases } from '../../command-context.js';
+import { syncOnceLocked } from '../../../modules/chat/sync/sync-service.js';
+import { getSyncStatus, formatSyncStatus } from '../../../modules/chat/sync/sync-status.js';
+import { getUnreadSummaryData, getUnreadPreview } from '../../../modules/chat/inbox/unread-service.js';
+import { readMessages } from '../../../modules/chat/inbox/read-service.js';
+import { getHistory } from '../../../modules/chat/inbox/history-service.js';
+import { searchLocalMessages } from '../../../modules/chat/inbox/search-service.js';
+import { listConversationsWithUnread, getConversationDetail } from '../../../modules/chat/inbox/conversation-service.js';
+import { sendMessage, editMessage, deleteMessage } from '../../../modules/chat/send/send-service.js';
+import { createConversation, inviteMember, removeMember, updateRole, leaveConversation } from '../../../modules/chat/send/conversation-service.js';
+import { renderMessageList } from '../../../modules/chat/render/message-render.js';
+import { output, renderTable } from '../../output.js';
+import { timeUntilNextPoll } from '../../../core/http/rate-limit.js';
+import { ensureValidAccessToken } from '../../../core/http/token-lifecycle.js';
+export function registerChatCommands(program) {
+    const chat = program.command('chat');
+    chat.description('Chat and messaging commands');
+    const sync = chat.command('sync');
+    sync.description('Chat synchronization commands');
+    sync
+        .command('once')
+        .description('Perform a one-shot sync')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .option('--force', 'Bypass rate limit check')
+        .option('--verbose', 'Show detailed progress')
+        .action(async (opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile. Use "fluxra profile use <name>"');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const report = await syncOnceLocked(coreDb, chatDb, profileName, {
+                    force: opts.force,
+                    verbose: opts.verbose,
+                });
+                if (opts.json) {
+                    output(report, { json: true });
+                }
+                else {
+                    if (report.success) {
+                        console.log('✓ Sync complete');
+                        console.log(`  Messages fetched:    ${report.messagesFetched}`);
+                        console.log(`  Messages inserted:   ${report.messagesInserted}`);
+                        console.log(`  Messages updated:    ${report.messagesUpdated}`);
+                        console.log(`  Conversations:       ${report.conversationsInserted} new, ${report.conversationsUpdated} updated`);
+                        console.log(`  New unread:          ${report.unreadDelta}`);
+                        if (report.rateLimit) {
+                            const wait = timeUntilNextPoll(report.rateLimit.nextPollAfter);
+                            if (wait !== null && wait > 0) {
+                                console.log(`  Next poll allowed:   in ${wait}s`);
+                            }
+                            else {
+                                console.log('  Next poll allowed:   now');
+                            }
+                        }
+                    }
+                    else {
+                        console.error(`✗ Sync failed: ${report.error}`);
+                        process.exit(1);
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    sync
+        .command('status')
+        .description('Show sync status')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action((opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile. Use "fluxra profile use <name>"');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const status = getSyncStatus(chatDb);
+                if (opts.json) {
+                    output(status, { json: true });
+                }
+                else {
+                    console.log(formatSyncStatus(status));
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    sync
+        .command('watch')
+        .description('Start foreground watch mode')
+        .option('--profile <name>', 'Profile to use')
+        .option('--interval <sec>', 'Poll interval in seconds', '60')
+        .option('--max-runs <n>', 'Maximum number of runs')
+        .option('--backoff', 'Enable adaptive backoff')
+        .action(async (opts, command) => {
+        try {
+            const { startWatch } = await import('../../../modules/chat/sync/watch-mode.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(2);
+            }
+            const { coreDb } = openProfileDatabases(profileName);
+            try {
+                const maxRuns = opts.maxRuns ? parseInt(opts.maxRuns, 10) : undefined;
+                const result = await startWatch(coreDb, {
+                    profileName,
+                    intervalSec: parseInt(opts.interval, 10),
+                    maxRuns,
+                    backoff: opts.backoff,
+                });
+                console.log('');
+                console.log('Watch Mode Stopped');
+                console.log(`  Runs Completed: ${result.runsCompleted}`);
+                if (result.lastSuccess) {
+                    console.log(`  Last Success:   ${new Date(result.lastSuccess).toLocaleString()}`);
+                }
+                if (result.lastError) {
+                    console.log(`  Last Error:     ${result.lastError}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, coreDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    sync
+        .command('install-cron')
+        .description('Install cron entry for background sync')
+        .option('--profile <name>', 'Profile to use')
+        .option('--schedule <expr>', 'Cron expression (default: */5 * * * *)')
+        .action(async (opts, command) => {
+        try {
+            const { installCron } = await import('../../../modules/chat/sync/cron-manager.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(2);
+            }
+            const { coreDb } = openProfileDatabases(profileName);
+            try {
+                const result = await installCron(coreDb, {
+                    profileName,
+                    schedule: opts.schedule,
+                });
+                console.log(`✓ Cron installed for profile '${profileName}'`);
+                console.log(`  Schedule: ${result.schedule}`);
+            }
+            finally {
+                closeDatabases(coreDb, coreDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    sync
+        .command('uninstall-cron')
+        .description('Uninstall cron entry for background sync')
+        .option('--profile <name>', 'Profile to use')
+        .action(async (opts, command) => {
+        try {
+            const { uninstallCron } = await import('../../../modules/chat/sync/cron-manager.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(2);
+            }
+            const { coreDb } = openProfileDatabases(profileName);
+            try {
+                await uninstallCron(coreDb, profileName);
+                console.log(`✓ Cron uninstalled for profile '${profileName}'`);
+            }
+            finally {
+                closeDatabases(coreDb, coreDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('unread')
+        .description('Show unread messages summary')
+        .option('--profile <name>', 'Profile to use')
+        .option('--conversation <id>', 'Filter by conversation')
+        .option('--mentions', 'Show only mentions')
+        .option('--json', 'Output in JSON format')
+        .action((opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const summary = getUnreadSummaryData(chatDb, {
+                    mentionsOnly: opts.mentions,
+                    conversationId: opts.conversation,
+                });
+                if (opts.json) {
+                    output(summary, { json: true });
+                }
+                else {
+                    console.log('Unread Summary');
+                    console.log(`  Total unread:    ${summary.totalUnread}`);
+                    console.log(`  Mentions:        ${summary.totalMentions}`);
+                    if (summary.byConversation.length > 0) {
+                        console.log('');
+                        const headers = ['Conversation', 'Type', 'Unread', '@', 'Last'];
+                        const rows = summary.byConversation.map(c => [
+                            c.conversationName || c.conversationId.substring(0, 12),
+                            c.conversationType,
+                            String(c.unreadCount),
+                            c.hasMention ? '✓' : '',
+                            new Date(c.lastUnreadAt).toLocaleTimeString(),
+                        ]);
+                        console.log(renderTable(headers, rows));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('peek')
+        .description('Preview unread messages without marking read')
+        .option('--profile <name>', 'Profile to use')
+        .option('--conversation <id>', 'Filter by conversation')
+        .option('--mentions', 'Show only mentions')
+        .option('--limit <n>', 'Max messages to show')
+        .option('--json', 'Output in JSON format')
+        .action((opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const preview = getUnreadPreview(chatDb, {
+                    conversationId: opts.conversation,
+                    limit: opts.limit ? parseInt(opts.limit, 10) : 20,
+                    mentionsOnly: opts.mentions,
+                    historyBefore: 5,
+                });
+                if (opts.json) {
+                    output(preview, { json: true });
+                }
+                else {
+                    if (preview.messages.length === 0) {
+                        console.log('No unread messages.');
+                    }
+                    else {
+                        console.log(`Unread Messages (${preview.totalUnread} unread)`);
+                        console.log(renderMessageList(preview.messages));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('read')
+        .description('Mark unread messages as read')
+        .option('--profile <name>', 'Profile to use')
+        .option('--conversation <id>', 'Mark conversation as read')
+        .option('--mentions', 'Mark only mentions as read')
+        .option('--limit <n>', 'Max messages to mark')
+        .option('--json', 'Output in JSON format')
+        .action((opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const result = readMessages(chatDb, {
+                    conversationId: opts.conversation,
+                    limit: opts.limit ? parseInt(opts.limit, 10) : 50,
+                    mentionsOnly: opts.mentions,
+                });
+                if (opts.json) {
+                    output(result, { json: true });
+                }
+                else {
+                    console.log(`✓ Marked ${result.markedRead} message(s) as read`);
+                    if (result.messages.length > 0) {
+                        console.log(renderMessageList(result.messages.slice(0, 10)));
+                        if (result.messages.length > 10) {
+                            console.log(`... and ${result.messages.length - 10} more`);
+                        }
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('conversations')
+        .description('List conversations with unread counts')
+        .option('--profile <name>', 'Profile to use')
+        .option('--unread-only', 'Show only conversations with unread')
+        .option('--limit <n>', 'Max conversations to show')
+        .option('--json', 'Output in JSON format')
+        .action((opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const conversations = listConversationsWithUnread(chatDb, {
+                    limit: opts.limit ? parseInt(opts.limit, 10) : 50,
+                    unreadOnly: opts.unreadOnly,
+                });
+                if (opts.json) {
+                    output(conversations, { json: true });
+                }
+                else {
+                    if (conversations.length === 0) {
+                        console.log('No conversations found.');
+                    }
+                    else {
+                        const headers = ['Name', 'Type', 'Unread', 'Last Activity'];
+                        const rows = conversations.map(c => [
+                            c.name || c.conversationId.substring(0, 12),
+                            c.type,
+                            c.unreadCount > 0 ? String(c.unreadCount) : '',
+                            c.lastMessageAt ? new Date(c.lastMessageAt).toLocaleString() : '',
+                        ]);
+                        console.log(renderTable(headers, rows));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('history')
+        .description('Browse message history of a conversation')
+        .argument('<conversation-id>', 'Conversation ID')
+        .option('--profile <name>', 'Profile to use')
+        .option('--limit <n>', 'Number of messages')
+        .option('--before <cursor>', 'Before timestamp')
+        .option('--json', 'Output in JSON format')
+        .action((convId, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const history = getHistory(chatDb, convId, {
+                    limit: opts.limit ? parseInt(opts.limit, 10) : 50,
+                    before: opts.before,
+                });
+                if (opts.json) {
+                    output(history, { json: true });
+                }
+                else {
+                    if (history.messages.length === 0) {
+                        console.log('No messages in history.');
+                    }
+                    else {
+                        console.log(`Message History (${history.messages.length} messages)`);
+                        if (history.hasMore) {
+                            console.log(`(More available, use --before ${history.nextCursor})`);
+                        }
+                        console.log('');
+                        console.log(renderMessageList(history.messages));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('search')
+        .description('Search local message cache')
+        .argument('<query>', 'Search query')
+        .option('--profile <name>', 'Profile to use')
+        .option('--conversation <id>', 'Search in specific conversation')
+        .option('--unread-only', 'Search only unread messages')
+        .option('--limit <n>', 'Max results')
+        .option('--json', 'Output in JSON format')
+        .action((query, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const results = searchLocalMessages(chatDb, query, {
+                    conversationId: opts.conversation,
+                    unreadOnly: opts.unreadOnly,
+                    limit: opts.limit ? parseInt(opts.limit, 10) : 50,
+                });
+                if (opts.json) {
+                    output(results, { json: true });
+                }
+                else {
+                    if (results.results.length === 0) {
+                        console.log(`No results for '${query}'.`);
+                    }
+                    else {
+                        console.log(`Search Results for '${query}' (${results.totalCount} found)`);
+                        console.log('');
+                        console.log(renderMessageList(results.results, { groupByConversation: true }));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('send')
+        .description('Send a message')
+        .argument('<target>', 'Target conversation ID or agent ID')
+        .argument('<content>', 'Message content')
+        .option('--profile <name>', 'Profile to use')
+        .option('--reply-to <msg-id>', 'Reply to message ID')
+        .option('--mention <agent-id>', 'Mention agent (repeatable)', (val, prev) => [...prev, val], [])
+        .option('--json', 'Output in JSON format')
+        .action(async (target, content, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                // Auto-detect target type
+                const isAgentId = target.startsWith('agt_');
+                const sendOpts = {
+                    content,
+                    conversationId: isAgentId ? undefined : target,
+                    recipientAgentId: isAgentId ? target : undefined,
+                    inReplyTo: opts.replyTo,
+                    mentions: opts.mention.length > 0 ? opts.mention : undefined,
+                };
+                const result = await sendMessage(chatDb, accessToken, sendOpts);
+                if (opts.json) {
+                    output(result, { json: true });
+                }
+                else {
+                    console.log(`✓ Message sent`);
+                    console.log(`  To: ${target}`);
+                    console.log(`  ID: ${result.message.message_id}`);
+                    if (result.outboxId) {
+                        console.log(`  ⚠  Queued to outbox (will retry later)`);
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('edit')
+        .description('Edit a message')
+        .argument('<message-id>', 'Message ID to edit')
+        .argument('<content>', 'New content')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (messageId, content, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                const result = await editMessage(chatDb, accessToken, messageId, content);
+                if (opts.json) {
+                    output(result, { json: true });
+                }
+                else {
+                    console.log(`✓ Message edited`);
+                    console.log(`  ID: ${result.messageId}`);
+                    console.log(`  Content: ${result.content}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('delete')
+        .description('Delete or withdraw a message')
+        .argument('<message-id>', 'Message ID')
+        .option('--profile <name>', 'Profile to use')
+        .option('--withdraw', 'Withdraw instead of delete')
+        .option('--json', 'Output in JSON format')
+        .action(async (messageId, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                const result = await deleteMessage(chatDb, accessToken, messageId, {
+                    withdraw: opts.withdraw,
+                });
+                if (opts.json) {
+                    output(result, { json: true });
+                }
+                else {
+                    const action = opts.withdraw ? 'withdrawn' : 'deleted';
+                    console.log(`✓ Message ${action}`);
+                    console.log(`  ID: ${result.messageId}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    // Conversation subcommands
+    const conv = chat.command('conv');
+    conv.description('Conversation management commands');
+    conv
+        .command('show')
+        .description('Show conversation detail')
+        .argument('<conversation-id>', 'Conversation ID')
+        .option('--profile <name>', 'Profile to use')
+        .option('--history <n>', 'Number of recent messages')
+        .option('--json', 'Output in JSON format')
+        .action(async (convId, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const detail = getConversationDetail(chatDb, convId, {
+                    historyLimit: opts.history ? parseInt(opts.history, 10) : 20,
+                });
+                if (!detail) {
+                    console.error(`Error: Conversation '${convId}' not found`);
+                    process.exit(1);
+                }
+                if (opts.json) {
+                    output(detail, { json: true });
+                }
+                else {
+                    console.log(`Conversation: ${detail.conversation.name || convId}`);
+                    console.log(`  Type:          ${detail.conversation.type}`);
+                    console.log(`  Created:       ${new Date(detail.conversation.created_at).toLocaleString()}`);
+                    console.log(`  Unread:        ${detail.unreadStats?.totalUnread || 0}`);
+                    if (detail.unreadStats && detail.unreadStats.mentionedUnread > 0) {
+                        console.log(`  Mentions:      ${detail.unreadStats.mentionedUnread}`);
+                    }
+                    if (detail.participants.length > 0) {
+                        console.log('');
+                        console.log('Participants:');
+                        for (const p of detail.participants) {
+                            console.log(`  - ${p.agent_id} (${p.role})`);
+                        }
+                    }
+                    if (detail.recentMessages.length > 0) {
+                        console.log('');
+                        console.log('Recent Messages:');
+                        console.log(renderMessageList(detail.recentMessages));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    conv
+        .command('create')
+        .description('Create a new conversation')
+        .option('--profile <name>', 'Profile to use')
+        .requiredOption('--type <type>', 'Conversation type (direct or group)')
+        .option('--name <name>', 'Conversation name')
+        .option('--member <agent-id>', 'Member to add (repeatable)', (val, prev) => [...prev, val], [])
+        .option('--json', 'Output in JSON format')
+        .action(async (opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            if (opts.type !== 'direct' && opts.type !== 'group') {
+                console.error('Error: Type must be "direct" or "group"');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                const result = await createConversation(chatDb, accessToken, {
+                    type: opts.type,
+                    name: opts.name,
+                    members: opts.member.length > 0 ? opts.member : undefined,
+                });
+                if (opts.json) {
+                    output(result, { json: true });
+                }
+                else {
+                    console.log(`✓ Conversation created`);
+                    console.log(`  ID: ${result.conversationId}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    conv
+        .command('invite')
+        .description('Invite a member to a conversation')
+        .argument('<conversation-id>', 'Conversation ID')
+        .argument('<agent-id>', 'Agent ID to invite')
+        .option('--profile <name>', 'Profile to use')
+        .option('--role <role>', 'Role (owner, admin, member)', 'member')
+        .option('--json', 'Output in JSON format')
+        .action(async (convId, agentId, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                const result = await inviteMember(chatDb, accessToken, convId, agentId, opts.role);
+                if (opts.json) {
+                    output(result, { json: true });
+                }
+                else {
+                    console.log(`✓ Invited ${agentId} to conversation`);
+                    console.log(`  Role: ${result.role}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    conv
+        .command('remove')
+        .description('Remove a member from a conversation')
+        .argument('<conversation-id>', 'Conversation ID')
+        .argument('<agent-id>', 'Agent ID to remove')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (convId, agentId, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                await removeMember(chatDb, accessToken, convId, agentId);
+                if (opts.json) {
+                    output({ success: true, agentId }, { json: true });
+                }
+                else {
+                    console.log(`✓ Removed ${agentId} from conversation`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    conv
+        .command('role')
+        .description('Update a member role')
+        .argument('<conversation-id>', 'Conversation ID')
+        .argument('<agent-id>', 'Agent ID')
+        .argument('<role>', 'New role (owner, admin, member)')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (convId, agentId, role, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                const result = await updateRole(chatDb, accessToken, convId, agentId, role);
+                if (opts.json) {
+                    output(result, { json: true });
+                }
+                else {
+                    console.log(`✓ Updated ${agentId} role to ${role}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    conv
+        .command('leave')
+        .description('Leave a conversation')
+        .argument('<conversation-id>', 'Conversation ID')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (convId, opts, command) => {
+        try {
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const accessToken = await ensureValidAccessToken(profileName);
+                await leaveConversation(chatDb, accessToken, convId);
+                if (opts.json) {
+                    output({ success: true, conversationId: convId }, { json: true });
+                }
+                else {
+                    console.log(`✓ Left conversation ${convId}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    // Block commands
+    chat
+        .command('block')
+        .description('Block an agent or conversation')
+        .argument('<target-id>', 'Target ID to block')
+        .option('--profile <name>', 'Profile to use')
+        .option('--type <type>', 'Block type (agent or group)', 'agent')
+        .option('--json', 'Output in JSON format')
+        .action(async (targetId, opts, command) => {
+        try {
+            const { createBlock } = await import('../../../core/http/block-api.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const accessToken = await ensureValidAccessToken(profileName);
+            const block = await createBlock(accessToken, {
+                type: opts.type,
+                target_id: targetId,
+            });
+            if (opts.json) {
+                output(block, { json: true });
+            }
+            else {
+                console.log(`✓ Blocked ${targetId}`);
+                console.log(`  Block ID: ${block.block_id}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('unblock')
+        .description('Unblock an agent or conversation')
+        .argument('<block-id>', 'Block ID to remove')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (blockId, opts, command) => {
+        try {
+            const { removeBlock } = await import('../../../core/http/block-api.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const accessToken = await ensureValidAccessToken(profileName);
+            await removeBlock(accessToken, blockId);
+            if (opts.json) {
+                output({ success: true, blockId }, { json: true });
+            }
+            else {
+                console.log(`✓ Unblocked ${blockId}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    chat
+        .command('blocks')
+        .description('List all blocks')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (opts, command) => {
+        try {
+            const { listBlocks } = await import('../../../core/http/block-api.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const accessToken = await ensureValidAccessToken(profileName);
+            const blocks = await listBlocks(accessToken);
+            if (opts.json) {
+                output(blocks, { json: true });
+            }
+            else {
+                if (blocks.blocks.length === 0) {
+                    console.log('No blocks.');
+                }
+                else {
+                    const headers = ['Block ID', 'Type', 'Target ID', 'Created'];
+                    const rows = blocks.blocks.map(b => [
+                        b.block_id || "<unknown>",
+                        b.type || "<unknown>",
+                        b.target_id || "<unknown>",
+                        b.created_at ? new Date(b.created_at).toLocaleString() : "<unknown>",
+                    ]);
+                    console.log(renderTable(headers, rows));
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    // Directory commands
+    const directory = chat.command('directory');
+    directory.description('Agent directory commands');
+    const dirSearch = directory.command('search');
+    dirSearch.description('Search agent directory');
+    dirSearch
+        .argument('<query>', 'Search query')
+        .description('Search for agents')
+        .option('--profile <name>', 'Profile to use')
+        .option('--limit <n>', 'Max results')
+        .option('--json', 'Output in JSON format')
+        .action(async (query, opts, command) => {
+        try {
+            const { searchDirectory } = await import('../../../core/http/directory-api.js');
+            const { cacheSearchResults } = await import('../../../modules/chat/send/directory-cache-service.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const results = await searchDirectory(query, {
+                    limit: opts.limit ? parseInt(opts.limit, 10) : 20,
+                });
+                // Cache results
+                cacheSearchResults(chatDb, results.profiles);
+                if (opts.json) {
+                    output(results, { json: true });
+                }
+                else {
+                    if (results.profiles.length === 0) {
+                        console.log(`No results for '${query}'.`);
+                    }
+                    else {
+                        console.log(`Search Results for '${query}' (${results.profiles.length} found)`);
+                        const headers = ['Agent ID', 'Name', 'Category', 'Status'];
+                        const rows = results.profiles.map(a => [
+                            a.agent_id,
+                            a.display_name || '<unnamed>',
+                            a.category || '<none>',
+                            a.status || '<none>',
+                        ]);
+                        console.log(renderTable(headers, rows));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    directory
+        .command('random')
+        .description('Get random agent recommendations')
+        .option('--profile <name>', 'Profile to use')
+        .option('--limit <n>', 'Number of recommendations')
+        .option('--json', 'Output in JSON format')
+        .action(async (opts, command) => {
+        try {
+            const { getRandomRecommendations } = await import('../../../core/http/directory-api.js');
+            const { cacheSearchResults } = await import('../../../modules/chat/send/directory-cache-service.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                const agents = await getRandomRecommendations(opts.limit ? parseInt(opts.limit, 10) : 10);
+                // Cache results
+                cacheSearchResults(chatDb, agents);
+                if (opts.json) {
+                    output(agents, { json: true });
+                }
+                else {
+                    if (agents.length === 0) {
+                        console.log('No recommendations available.');
+                    }
+                    else {
+                        console.log('Random Recommendations:');
+                        const headers = ['Agent ID', 'Name', 'Category', 'Status'];
+                        const rows = agents.map(a => [
+                            a.agent_id,
+                            a.display_name || '<unnamed>',
+                            a.category || '<none>',
+                            a.status || '<none>',
+                        ]);
+                        console.log(renderTable(headers, rows));
+                    }
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    const profile = directory.command('profile');
+    profile.description('Directory profile management');
+    profile
+        .command('get')
+        .description('Get agent profile')
+        .argument('<agent-id>', 'Agent ID')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (agentId, opts, command) => {
+        try {
+            const { getAgentProfile: getApi } = await import('../../../core/http/directory-api.js');
+            const { getAgentProfile: getCached } = await import('../../../modules/chat/store/directory-cache-repo.js');
+            const { cacheProfile } = await import('../../../modules/chat/send/directory-cache-service.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                // Check cache first
+                let cachedProfile = getCached(chatDb, agentId);
+                if (!cachedProfile) {
+                    // Fetch from API
+                    const accessToken = await ensureValidAccessToken(profileName);
+                    const apiProfile = await getApi(agentId, accessToken);
+                    cacheProfile(chatDb, {
+                        agent_id: apiProfile.agent_id,
+                        display_name: apiProfile.display_name,
+                        introduction: apiProfile.introduction,
+                        category: apiProfile.category,
+                        status: apiProfile.status,
+                    });
+                    cachedProfile = {
+                        agent_id: apiProfile.agent_id,
+                        display_name: apiProfile.display_name || null,
+                        introduction: apiProfile.introduction || null,
+                        category: apiProfile.category || null,
+                        status: apiProfile.status || null,
+                        cached_at: new Date().toISOString(),
+                    };
+                }
+                if (opts.json) {
+                    output(cachedProfile, { json: true });
+                }
+                else {
+                    console.log(`Agent Profile: ${agentId}`);
+                    console.log(`  Name:         ${cachedProfile.display_name || '<unnamed>'}`);
+                    console.log(`  Category:     ${cachedProfile.category || '<none>'}`);
+                    console.log(`  Introduction: ${cachedProfile.introduction || '<none>'}`);
+                }
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    profile
+        .command('set')
+        .description('Create or update your profile')
+        .option('--profile <name>', 'Profile to use')
+        .option('--intro <text>', 'Introduction text')
+        .option('--category <cat>', 'Category')
+        .option('--status <status>', 'Status (active, inactive, busy)')
+        .option('--json', 'Output in JSON format')
+        .action(async (opts, command) => {
+        try {
+            const { upsertProfile: upsertApi } = await import('../../../core/http/directory-profile-api.js');
+            const { cacheProfile } = await import('../../../modules/chat/send/directory-cache-service.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const accessToken = await ensureValidAccessToken(profileName);
+            const apiProfile = await upsertApi(accessToken, {
+                introduction: opts.intro,
+                category: opts.category,
+                status: opts.status,
+            });
+            // Cache the profile
+            const { coreDb, chatDb } = openProfileDatabases(profileName);
+            try {
+                cacheProfile(chatDb, {
+                    agent_id: apiProfile.agent_id,
+                    display_name: apiProfile.agent_id,
+                    introduction: apiProfile.introduction,
+                    category: apiProfile.category,
+                    status: apiProfile.status,
+                });
+            }
+            finally {
+                closeDatabases(coreDb, chatDb);
+            }
+            if (opts.json) {
+                output(apiProfile, { json: true });
+            }
+            else {
+                console.log('✓ Profile updated');
+                console.log(`  Agent ID: ${apiProfile.agent_id}`);
+                console.log(`  Category: ${apiProfile.category || '<none>'}`);
+                console.log(`  Status:   ${apiProfile.status || '<none>'}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+    profile
+        .command('delete')
+        .description('Delete your profile')
+        .option('--profile <name>', 'Profile to use')
+        .option('--json', 'Output in JSON format')
+        .action(async (opts, command) => {
+        try {
+            const { deleteProfile: deleteApi } = await import('../../../core/http/directory-profile-api.js');
+            const profileName = resolveProfile(opts, command);
+            if (!profileName) {
+                console.error('Error: No active profile');
+                process.exit(1);
+            }
+            const accessToken = await ensureValidAccessToken(profileName);
+            await deleteApi(accessToken);
+            if (opts.json) {
+                output({ success: true }, { json: true });
+            }
+            else {
+                console.log('✓ Profile deleted');
+            }
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=index.js.map