kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/session.js

@@ -1,7 +1,43 @@
 /**
  * V3 CLI Session Command
- * Session management for KynjalFlow
+ * Session management for Claude Flow
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../output.js';
 import { confirm, input, select } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
@@ -9,17 +45,17 @@ import * as fs from 'fs';
 import * as path from 'path';
 // Format date for display
 function formatDate(dateStr) {
-    const date = new Date(dateStr);
-    const now = new Date();
-    const diff = now.getTime() - date.getTime();
+    var date = new Date(dateStr);
+    var now = new Date();
+    var diff = now.getTime() - date.getTime();
     // Less than 24 hours - show relative time
     if (diff < 24 * 60 * 60 * 1000) {
-        const hours = Math.floor(diff / (60 * 60 * 1000));
-        const minutes = Math.floor((diff % (60 * 60 * 1000)) / (60 * 1000));
+        var hours = Math.floor(diff / (60 * 60 * 1000));
+        var minutes = Math.floor((diff % (60 * 60 * 1000)) / (60 * 1000));
         if (hours > 0) {
-            return `${hours}h ${minutes}m ago`;
+            return hours + "h " + minutes + "m ago";
         }
-        return `${minutes}m ago`;
+        return minutes + "m ago";
     }
     // Otherwise show date
     return date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
@@ -38,7 +74,7 @@ function formatStatus(status) {
     }
 }
 // List subcommand
-const listCommand = {
+var listCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List all sessions',
@@ -48,78 +84,88 @@ const listCommand = {
             short: 'a',
             description: 'Show only active sessions',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'all',
             description: 'Include archived sessions',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'limit',
             short: 'l',
             description: 'Maximum sessions to show',
             type: 'number',
-            default: 20
+            "default": 20
         }
     ],
-    action: async (ctx) => {
-        const activeOnly = ctx.flags.active;
-        const includeArchived = ctx.flags.all;
-        const limit = ctx.flags.limit;
-        try {
-            const result = await callMCPTool('session_list', {
-                status: activeOnly ? 'active' : includeArchived ? 'all' : 'active,saved',
-                limit
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Sessions'));
-            output.writeln();
-            if (result.sessions.length === 0) {
-                output.printInfo('No sessions found');
-                output.printInfo('Run "claude-flow session save" to create a session');
-                return { success: true, data: result };
-            }
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'ID', width: 20 },
-                    { key: 'name', header: 'Name', width: 20 },
-                    { key: 'status', header: 'Status', width: 10 },
-                    { key: 'agents', header: 'Agents', width: 8, align: 'right' },
-                    { key: 'tasks', header: 'Tasks', width: 8, align: 'right' },
-                    { key: 'updated', header: 'Last Updated', width: 18 }
-                ],
-                data: result.sessions.map(s => ({
-                    id: s.id,
-                    name: s.name || '-',
-                    status: formatStatus(s.status),
-                    agents: s.agentCount,
-                    tasks: s.taskCount,
-                    updated: formatDate(s.updatedAt)
-                }))
-            });
-            output.writeln();
-            output.printInfo(`Showing ${result.sessions.length} of ${result.total} sessions`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to list sessions: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var activeOnly, includeArchived, limit, result, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    activeOnly = ctx.flags.active;
+                    includeArchived = ctx.flags.all;
+                    limit = ctx.flags.limit;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, callMCPTool('session_list', {
+                            status: activeOnly ? 'active' : includeArchived ? 'all' : 'active,saved',
+                            limit: limit
+                        })];
+                case 2:
+                    result = _a.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold('Sessions'));
+                    output.writeln();
+                    if (result.sessions.length === 0) {
+                        output.printInfo('No sessions found');
+                        output.printInfo('Run "claude-flow session save" to create a session');
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.printTable({
+                        columns: [
+                            { key: 'id', header: 'ID', width: 20 },
+                            { key: 'name', header: 'Name', width: 20 },
+                            { key: 'status', header: 'Status', width: 10 },
+                            { key: 'agents', header: 'Agents', width: 8, align: 'right' },
+                            { key: 'tasks', header: 'Tasks', width: 8, align: 'right' },
+                            { key: 'updated', header: 'Last Updated', width: 18 }
+                        ],
+                        data: result.sessions.map(function (s) { return ({
+                            id: s.id,
+                            name: s.name || '-',
+                            status: formatStatus(s.status),
+                            agents: s.agentCount,
+                            tasks: s.taskCount,
+                            updated: formatDate(s.updatedAt)
+                        }); })
+                    });
+                    output.writeln();
+                    output.printInfo("Showing " + result.sessions.length + " of " + result.total + " sessions");
+                    return [2 /*return*/, { success: true, data: result }];
+                case 3:
+                    error_1 = _a.sent();
+                    if (error_1 instanceof MCPClientError) {
+                        output.printError("Failed to list sessions: " + error_1.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_1));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Save subcommand
-const saveCommand = {
+var saveCommand = {
     name: 'save',
     aliases: ['create', 'checkpoint'],
     description: 'Save current session state',
@@ -140,88 +186,103 @@ const saveCommand = {
             name: 'include-memory',
             description: 'Include memory state in session',
             type: 'boolean',
-            default: true
+            "default": true
         },
         {
             name: 'include-agents',
             description: 'Include agent state in session',
             type: 'boolean',
-            default: true
+            "default": true
         },
         {
             name: 'include-tasks',
             description: 'Include task state in session',
             type: 'boolean',
-            default: true
+            "default": true
         }
     ],
-    action: async (ctx) => {
-        let sessionName = ctx.flags.name;
-        let description = ctx.flags.description;
-        // Interactive mode
-        if (!sessionName && ctx.interactive) {
-            sessionName = await input({
-                message: 'Session name:',
-                default: `session-${Date.now().toString(36)}`,
-                validate: (v) => v.length > 0 || 'Name is required'
-            });
-        }
-        if (!description && ctx.interactive) {
-            description = await input({
-                message: 'Session description (optional):',
-                default: ''
-            });
-        }
-        const spinner = output.createSpinner({ text: 'Saving session...' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('session_save', {
-                name: sessionName,
-                description,
-                includeMemory: ctx.flags['include-memory'] !== false,
-                includeAgents: ctx.flags['include-agents'] !== false,
-                includeTasks: ctx.flags['include-tasks'] !== false
-            });
-            spinner.succeed('Session saved');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 18 },
-                    { key: 'value', header: 'Value', width: 35 }
-                ],
-                data: [
-                    { property: 'Session ID', value: result.sessionId },
-                    { property: 'Name', value: result.name },
-                    { property: 'Description', value: result.description || '-' },
-                    { property: 'Saved At', value: new Date(result.savedAt).toLocaleString() },
-                    { property: 'Agents', value: result.stats.agentCount },
-                    { property: 'Tasks', value: result.stats.taskCount },
-                    { property: 'Memory Entries', value: result.stats.memoryEntries },
-                    { property: 'Total Size', value: formatSize(result.stats.totalSize) }
-                ]
-            });
-            output.writeln();
-            output.printSuccess(`Session saved: ${result.sessionId}`);
-            output.printInfo(`Restore with: claude-flow session restore ${result.sessionId}`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Failed to save session');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var sessionName, description, spinner, result, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sessionName = ctx.flags.name;
+                    description = ctx.flags.description;
+                    if (!(!sessionName && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, input({
+                            message: 'Session name:',
+                            "default": "session-" + Date.now().toString(36),
+                            validate: function (v) { return v.length > 0 || 'Name is required'; }
+                        })];
+                case 1:
+                    sessionName = _a.sent();
+                    _a.label = 2;
+                case 2:
+                    if (!(!description && ctx.interactive)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, input({
+                            message: 'Session description (optional):',
+                            "default": ''
+                        })];
+                case 3:
+                    description = _a.sent();
+                    _a.label = 4;
+                case 4:
+                    spinner = output.createSpinner({ text: 'Saving session...' });
+                    spinner.start();
+                    _a.label = 5;
+                case 5:
+                    _a.trys.push([5, 7, , 8]);
+                    return [4 /*yield*/, callMCPTool('session_save', {
+                            name: sessionName,
+                            description: description,
+                            includeMemory: ctx.flags['include-memory'] !== false,
+                            includeAgents: ctx.flags['include-agents'] !== false,
+                            includeTasks: ctx.flags['include-tasks'] !== false
+                        })];
+                case 6:
+                    result = _a.sent();
+                    spinner.succeed('Session saved');
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 18 },
+                            { key: 'value', header: 'Value', width: 35 }
+                        ],
+                        data: [
+                            { property: 'Session ID', value: result.sessionId },
+                            { property: 'Name', value: result.name },
+                            { property: 'Description', value: result.description || '-' },
+                            { property: 'Saved At', value: new Date(result.savedAt).toLocaleString() },
+                            { property: 'Agents', value: result.stats.agentCount },
+                            { property: 'Tasks', value: result.stats.taskCount },
+                            { property: 'Memory Entries', value: result.stats.memoryEntries },
+                            { property: 'Total Size', value: formatSize(result.stats.totalSize) }
+                        ]
+                    });
+                    output.writeln();
+                    output.printSuccess("Session saved: " + result.sessionId);
+                    output.printInfo("Restore with: claude-flow session restore " + result.sessionId);
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 7:
+                    error_2 = _a.sent();
+                    spinner.fail('Failed to save session');
+                    if (error_2 instanceof MCPClientError) {
+                        output.printError("Error: " + error_2.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_2));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 8: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Restore subcommand
-const restoreCommand = {
+var restoreCommand = {
     name: 'restore',
     aliases: ['load'],
     description: 'Restore a saved session',
@@ -231,130 +292,146 @@ const restoreCommand = {
             short: 'f',
             description: 'Overwrite current state without confirmation',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'memory-only',
             description: 'Only restore memory state',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'agents-only',
             description: 'Only restore agent state',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'tasks-only',
             description: 'Only restore task state',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        let sessionId = ctx.args[0];
-        const force = ctx.flags.force;
-        if (!sessionId && ctx.interactive) {
-            // Show list to select from
-            try {
-                const sessions = await callMCPTool('session_list', { status: 'saved', limit: 20 });
-                if (sessions.sessions.length === 0) {
-                    output.printWarning('No saved sessions found');
-                    return { success: false, exitCode: 1 };
-                }
-                sessionId = await select({
-                    message: 'Select session to restore:',
-                    options: sessions.sessions.map(s => ({
-                        value: s.id,
-                        label: s.name || s.id,
-                        hint: formatDate(s.updatedAt)
-                    }))
-                });
-            }
-            catch (error) {
-                if (error instanceof Error && error.message === 'User cancelled') {
-                    output.printInfo('Operation cancelled');
-                    return { success: true };
-                }
-                throw error;
-            }
-        }
-        if (!sessionId) {
-            output.printError('Session ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        // Confirm unless forced
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: 'This will overwrite current state. Continue?',
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        const spinner = output.createSpinner({ text: 'Restoring session...' });
-        spinner.start();
-        try {
-            // Determine what to restore
-            const restoreMemory = !ctx.flags['agents-only'] && !ctx.flags['tasks-only'];
-            const restoreAgents = !ctx.flags['memory-only'] && !ctx.flags['tasks-only'];
-            const restoreTasks = !ctx.flags['memory-only'] && !ctx.flags['agents-only'];
-            const result = await callMCPTool('session_restore', {
-                sessionId,
-                restoreMemory,
-                restoreAgents,
-                restoreTasks
-            });
-            spinner.succeed('Session restored');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'component', header: 'Component', width: 20 },
-                    { key: 'status', header: 'Status', width: 15 },
-                    { key: 'count', header: 'Items', width: 10, align: 'right' }
-                ],
-                data: [
-                    {
-                        component: 'Memory',
-                        status: result.restored.memory ? output.success('Restored') : output.dim('Skipped'),
-                        count: result.stats.memoryEntriesRestored
-                    },
-                    {
-                        component: 'Agents',
-                        status: result.restored.agents ? output.success('Restored') : output.dim('Skipped'),
-                        count: result.stats.agentsRestored
-                    },
-                    {
-                        component: 'Tasks',
-                        status: result.restored.tasks ? output.success('Restored') : output.dim('Skipped'),
-                        count: result.stats.tasksRestored
-                    }
-                ]
-            });
-            output.writeln();
-            output.printSuccess(`Session ${sessionId} restored successfully`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Failed to restore session');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var sessionId, force, sessions, error_3, confirmed, spinner, restoreMemory, restoreAgents, restoreTasks, result, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sessionId = ctx.args[0];
+                    force = ctx.flags.force;
+                    if (!(!sessionId && ctx.interactive)) return [3 /*break*/, 5];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, callMCPTool('session_list', { status: 'saved', limit: 20 })];
+                case 2:
+                    sessions = _a.sent();
+                    if (sessions.sessions.length === 0) {
+                        output.printWarning('No saved sessions found');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    return [4 /*yield*/, select({
+                            message: 'Select session to restore:',
+                            options: sessions.sessions.map(function (s) { return ({
+                                value: s.id,
+                                label: s.name || s.id,
+                                hint: formatDate(s.updatedAt)
+                            }); })
+                        })];
+                case 3:
+                    sessionId = _a.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    error_3 = _a.sent();
+                    if (error_3 instanceof Error && error_3.message === 'User cancelled') {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    throw error_3;
+                case 5:
+                    if (!sessionId) {
+                        output.printError('Session ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    if (!(!force && ctx.interactive)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, confirm({
+                            message: 'This will overwrite current state. Continue?',
+                            "default": false
+                        })];
+                case 6:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _a.label = 7;
+                case 7:
+                    spinner = output.createSpinner({ text: 'Restoring session...' });
+                    spinner.start();
+                    _a.label = 8;
+                case 8:
+                    _a.trys.push([8, 10, , 11]);
+                    restoreMemory = !ctx.flags['agents-only'] && !ctx.flags['tasks-only'];
+                    restoreAgents = !ctx.flags['memory-only'] && !ctx.flags['tasks-only'];
+                    restoreTasks = !ctx.flags['memory-only'] && !ctx.flags['agents-only'];
+                    return [4 /*yield*/, callMCPTool('session_restore', {
+                            sessionId: sessionId,
+                            restoreMemory: restoreMemory,
+                            restoreAgents: restoreAgents,
+                            restoreTasks: restoreTasks
+                        })];
+                case 9:
+                    result = _a.sent();
+                    spinner.succeed('Session restored');
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'component', header: 'Component', width: 20 },
+                            { key: 'status', header: 'Status', width: 15 },
+                            { key: 'count', header: 'Items', width: 10, align: 'right' }
+                        ],
+                        data: [
+                            {
+                                component: 'Memory',
+                                status: result.restored.memory ? output.success('Restored') : output.dim('Skipped'),
+                                count: result.stats.memoryEntriesRestored
+                            },
+                            {
+                                component: 'Agents',
+                                status: result.restored.agents ? output.success('Restored') : output.dim('Skipped'),
+                                count: result.stats.agentsRestored
+                            },
+                            {
+                                component: 'Tasks',
+                                status: result.restored.tasks ? output.success('Restored') : output.dim('Skipped'),
+                                count: result.stats.tasksRestored
+                            }
+                        ]
+                    });
+                    output.writeln();
+                    output.printSuccess("Session " + sessionId + " restored successfully");
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 10:
+                    error_4 = _a.sent();
+                    spinner.fail('Failed to restore session');
+                    if (error_4 instanceof MCPClientError) {
+                        output.printError("Error: " + error_4.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_4));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 11: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Delete subcommand
-const deleteCommand = {
+var deleteCommand = {
     name: 'delete',
     aliases: ['rm', 'remove'],
     description: 'Delete a saved session',
@@ -364,48 +441,59 @@ const deleteCommand = {
             short: 'f',
             description: 'Delete without confirmation',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const sessionId = ctx.args[0];
-        const force = ctx.flags.force;
-        if (!sessionId) {
-            output.printError('Session ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Delete session ${sessionId}? This cannot be undone.`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        try {
-            const result = await callMCPTool('session_delete', { sessionId });
-            output.writeln();
-            output.printSuccess(`Session ${sessionId} deleted`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to delete session: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var sessionId, force, confirmed, result, error_5;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sessionId = ctx.args[0];
+                    force = ctx.flags.force;
+                    if (!sessionId) {
+                        output.printError('Session ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    if (!(!force && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, confirm({
+                            message: "Delete session " + sessionId + "? This cannot be undone.",
+                            "default": false
+                        })];
+                case 1:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, callMCPTool('session_delete', { sessionId: sessionId })];
+                case 3:
+                    result = _a.sent();
+                    output.writeln();
+                    output.printSuccess("Session " + sessionId + " deleted");
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 4:
+                    error_5 = _a.sent();
+                    if (error_5 instanceof MCPClientError) {
+                        output.printError("Failed to delete session: " + error_5.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_5));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 5: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Export subcommand
-const exportCommand = {
+var exportCommand = {
     name: 'export',
     description: 'Export session to file',
     options: [
@@ -421,100 +509,111 @@ const exportCommand = {
             description: 'Export format (json, yaml)',
             type: 'string',
             choices: ['json', 'yaml'],
-            default: 'json'
+            "default": 'json'
         },
         {
             name: 'include-memory',
             description: 'Include memory data',
             type: 'boolean',
-            default: true
+            "default": true
         },
         {
             name: 'compress',
             description: 'Compress output',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        let sessionId = ctx.args[0];
-        let outputPath = ctx.flags.output;
-        const exportFormat = ctx.flags.format;
-        const compress = ctx.flags.compress;
-        // Get current session if no ID provided
-        if (!sessionId) {
-            try {
-                const current = await callMCPTool('session_current', {});
-                sessionId = current.sessionId;
-            }
-            catch {
-                output.printError('No active session. Provide a session ID to export.');
-                return { success: false, exitCode: 1 };
-            }
-        }
-        // Generate output path if not provided
-        if (!outputPath) {
-            const ext = compress ? '.gz' : '';
-            outputPath = `session-${sessionId}.${exportFormat}${ext}`;
-        }
-        const spinner = output.createSpinner({ text: 'Exporting session...' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('session_export', {
-                sessionId,
-                includeMemory: ctx.flags['include-memory'] !== false
-            });
-            // Format output
-            let content;
-            if (exportFormat === 'yaml') {
-                content = toSimpleYaml(result.data);
-            }
-            else {
-                content = JSON.stringify(result.data, null, 2);
-            }
-            // Write to file
-            const absolutePath = path.isAbsolute(outputPath)
-                ? outputPath
-                : path.join(ctx.cwd, outputPath);
-            fs.writeFileSync(absolutePath, content, 'utf-8');
-            spinner.succeed('Session exported');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 18 },
-                    { key: 'value', header: 'Value', width: 40 }
-                ],
-                data: [
-                    { property: 'Session ID', value: sessionId },
-                    { property: 'Output File', value: absolutePath },
-                    { property: 'Format', value: exportFormat.toUpperCase() },
-                    { property: 'Agents', value: result.stats.agentCount },
-                    { property: 'Tasks', value: result.stats.taskCount },
-                    { property: 'Memory Entries', value: result.stats.memoryEntries },
-                    { property: 'File Size', value: formatSize(content.length) }
-                ]
-            });
-            output.writeln();
-            output.printSuccess(`Session exported to ${outputPath}`);
-            return {
-                success: true,
-                data: { sessionId, outputPath, format: exportFormat, size: content.length }
-            };
-        }
-        catch (error) {
-            spinner.fail('Failed to export session');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var sessionId, outputPath, exportFormat, compress, current, _a, ext, spinner, result, content, absolutePath, error_6;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    sessionId = ctx.args[0];
+                    outputPath = ctx.flags.output;
+                    exportFormat = ctx.flags.format;
+                    compress = ctx.flags.compress;
+                    if (!!sessionId) return [3 /*break*/, 4];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, callMCPTool('session_current', {})];
+                case 2:
+                    current = _b.sent();
+                    sessionId = current.sessionId;
+                    return [3 /*break*/, 4];
+                case 3:
+                    _a = _b.sent();
+                    output.printError('No active session. Provide a session ID to export.');
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4:
+                    // Generate output path if not provided
+                    if (!outputPath) {
+                        ext = compress ? '.gz' : '';
+                        outputPath = "session-" + sessionId + "." + exportFormat + ext;
+                    }
+                    spinner = output.createSpinner({ text: 'Exporting session...' });
+                    spinner.start();
+                    _b.label = 5;
+                case 5:
+                    _b.trys.push([5, 7, , 8]);
+                    return [4 /*yield*/, callMCPTool('session_export', {
+                            sessionId: sessionId,
+                            includeMemory: ctx.flags['include-memory'] !== false
+                        })];
+                case 6:
+                    result = _b.sent();
+                    content = void 0;
+                    if (exportFormat === 'yaml') {
+                        content = toSimpleYaml(result.data);
+                    }
+                    else {
+                        content = JSON.stringify(result.data, null, 2);
+                    }
+                    absolutePath = path.isAbsolute(outputPath)
+                        ? outputPath
+                        : path.join(ctx.cwd, outputPath);
+                    fs.writeFileSync(absolutePath, content, 'utf-8');
+                    spinner.succeed('Session exported');
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 18 },
+                            { key: 'value', header: 'Value', width: 40 }
+                        ],
+                        data: [
+                            { property: 'Session ID', value: sessionId },
+                            { property: 'Output File', value: absolutePath },
+                            { property: 'Format', value: exportFormat.toUpperCase() },
+                            { property: 'Agents', value: result.stats.agentCount },
+                            { property: 'Tasks', value: result.stats.taskCount },
+                            { property: 'Memory Entries', value: result.stats.memoryEntries },
+                            { property: 'File Size', value: formatSize(content.length) }
+                        ]
+                    });
+                    output.writeln();
+                    output.printSuccess("Session exported to " + outputPath);
+                    return [2 /*return*/, {
+                            success: true,
+                            data: { sessionId: sessionId, outputPath: outputPath, format: exportFormat, size: content.length }
+                        }];
+                case 7:
+                    error_6 = _b.sent();
+                    spinner.fail('Failed to export session');
+                    if (error_6 instanceof MCPClientError) {
+                        output.printError("Error: " + error_6.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_6));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 8: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Import subcommand
-const importCommand = {
+var importCommand = {
     name: 'import',
     description: 'Import session from file',
     options: [
@@ -528,149 +627,168 @@ const importCommand = {
             name: 'activate',
             description: 'Activate session after import',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const filePath = ctx.args[0];
-        const sessionName = ctx.flags.name;
-        const activate = ctx.flags.activate;
-        if (!filePath) {
-            output.printError('File path is required');
-            return { success: false, exitCode: 1 };
-        }
-        const absolutePath = path.isAbsolute(filePath)
-            ? filePath
-            : path.join(ctx.cwd, filePath);
-        if (!fs.existsSync(absolutePath)) {
-            output.printError(`File not found: ${absolutePath}`);
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Importing session...' });
-        spinner.start();
-        try {
-            const content = fs.readFileSync(absolutePath, 'utf-8');
-            let data;
-            // Parse based on extension
-            if (absolutePath.endsWith('.yaml') || absolutePath.endsWith('.yml')) {
-                // Simple YAML parsing (basic implementation)
-                data = JSON.parse(content); // Would need proper YAML parser
-            }
-            else {
-                data = JSON.parse(content);
-            }
-            const result = await callMCPTool('session_import', {
-                data,
-                name: sessionName,
-                activate
-            });
-            spinner.succeed('Session imported');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 35 }
-                ],
-                data: [
-                    { property: 'Session ID', value: result.sessionId },
-                    { property: 'Name', value: result.name },
-                    { property: 'Source File', value: path.basename(absolutePath) },
-                    { property: 'Agents Imported', value: result.stats.agentsImported },
-                    { property: 'Tasks Imported', value: result.stats.tasksImported },
-                    { property: 'Memory Entries', value: result.stats.memoryEntriesImported },
-                    { property: 'Activated', value: result.activated ? 'Yes' : 'No' }
-                ]
-            });
-            output.writeln();
-            output.printSuccess(`Session imported: ${result.sessionId}`);
-            if (!result.activated) {
-                output.printInfo(`Restore with: claude-flow session restore ${result.sessionId}`);
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Failed to import session');
-            if (error instanceof MCPClientError) {
-                output.printError(`Error: ${error.message}`);
-            }
-            else if (error instanceof SyntaxError) {
-                output.printError('Invalid file format. Expected JSON or YAML.');
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var filePath, sessionName, activate, absolutePath, spinner, content, data, result, error_7;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    filePath = ctx.args[0];
+                    sessionName = ctx.flags.name;
+                    activate = ctx.flags.activate;
+                    if (!filePath) {
+                        output.printError('File path is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    absolutePath = path.isAbsolute(filePath)
+                        ? filePath
+                        : path.join(ctx.cwd, filePath);
+                    if (!fs.existsSync(absolutePath)) {
+                        output.printError("File not found: " + absolutePath);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Importing session...' });
+                    spinner.start();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    content = fs.readFileSync(absolutePath, 'utf-8');
+                    data = void 0;
+                    // Parse based on extension
+                    if (absolutePath.endsWith('.yaml') || absolutePath.endsWith('.yml')) {
+                        // Simple YAML parsing (basic implementation)
+                        data = JSON.parse(content); // Would need proper YAML parser
+                    }
+                    else {
+                        data = JSON.parse(content);
+                    }
+                    return [4 /*yield*/, callMCPTool('session_import', {
+                            data: data,
+                            name: sessionName,
+                            activate: activate
+                        })];
+                case 2:
+                    result = _a.sent();
+                    spinner.succeed('Session imported');
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 20 },
+                            { key: 'value', header: 'Value', width: 35 }
+                        ],
+                        data: [
+                            { property: 'Session ID', value: result.sessionId },
+                            { property: 'Name', value: result.name },
+                            { property: 'Source File', value: path.basename(absolutePath) },
+                            { property: 'Agents Imported', value: result.stats.agentsImported },
+                            { property: 'Tasks Imported', value: result.stats.tasksImported },
+                            { property: 'Memory Entries', value: result.stats.memoryEntriesImported },
+                            { property: 'Activated', value: result.activated ? 'Yes' : 'No' }
+                        ]
+                    });
+                    output.writeln();
+                    output.printSuccess("Session imported: " + result.sessionId);
+                    if (!result.activated) {
+                        output.printInfo("Restore with: claude-flow session restore " + result.sessionId);
+                    }
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 3:
+                    error_7 = _a.sent();
+                    spinner.fail('Failed to import session');
+                    if (error_7 instanceof MCPClientError) {
+                        output.printError("Error: " + error_7.message);
+                    }
+                    else if (error_7 instanceof SyntaxError) {
+                        output.printError('Invalid file format. Expected JSON or YAML.');
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_7));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Current subcommand
-const currentCommand = {
+var currentCommand = {
     name: 'current',
     description: 'Show current active session',
-    action: async (ctx) => {
-        try {
-            const result = await callMCPTool('session_current', { includeStats: true });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Current Session'));
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 18 },
-                    { key: 'value', header: 'Value', width: 35 }
-                ],
-                data: [
-                    { property: 'Session ID', value: result.sessionId },
-                    { property: 'Name', value: result.name || '-' },
-                    { property: 'Status', value: formatStatus(result.status) },
-                    { property: 'Started', value: new Date(result.startedAt).toLocaleString() },
-                    { property: 'Duration', value: formatDuration(result.stats.duration) },
-                    { property: 'Agents', value: result.stats.agentCount },
-                    { property: 'Tasks', value: result.stats.taskCount },
-                    { property: 'Memory Entries', value: result.stats.memoryEntries }
-                ]
-            });
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printWarning('No active session');
-                output.printInfo('Start a session with "claude-flow start"');
-                return { success: true, data: { active: false } };
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var result, error_8;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, callMCPTool('session_current', { includeStats: true })];
+                case 1:
+                    result = _a.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold('Current Session'));
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 18 },
+                            { key: 'value', header: 'Value', width: 35 }
+                        ],
+                        data: [
+                            { property: 'Session ID', value: result.sessionId },
+                            { property: 'Name', value: result.name || '-' },
+                            { property: 'Status', value: formatStatus(result.status) },
+                            { property: 'Started', value: new Date(result.startedAt).toLocaleString() },
+                            { property: 'Duration', value: formatDuration(result.stats.duration) },
+                            { property: 'Agents', value: result.stats.agentCount },
+                            { property: 'Tasks', value: result.stats.taskCount },
+                            { property: 'Memory Entries', value: result.stats.memoryEntries }
+                        ]
+                    });
+                    return [2 /*return*/, { success: true, data: result }];
+                case 2:
+                    error_8 = _a.sent();
+                    if (error_8 instanceof MCPClientError) {
+                        output.printWarning('No active session');
+                        output.printInfo('Start a session with "claude-flow start"');
+                        return [2 /*return*/, { success: true, data: { active: false } }];
+                    }
+                    output.printError("Unexpected error: " + String(error_8));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 3: return [2 /*return*/];
             }
-            output.printError(`Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Helper functions
 function formatSize(bytes) {
     if (bytes === 0)
         return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+    var k = 1024;
+    var sizes = ['B', 'KB', 'MB', 'GB'];
+    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
 }
 function formatDuration(ms) {
-    const seconds = Math.floor(ms / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
+    var seconds = Math.floor(ms / 1000);
+    var minutes = Math.floor(seconds / 60);
+    var hours = Math.floor(minutes / 60);
     if (hours > 0) {
-        return `${hours}h ${minutes % 60}m`;
+        return hours + "h " + minutes % 60 + "m";
     }
     else if (minutes > 0) {
-        return `${minutes}m ${seconds % 60}s`;
+        return minutes + "m " + seconds % 60 + "s";
     }
-    return `${seconds}s`;
+    return seconds + "s";
 }
-function toSimpleYaml(obj, indent = 0) {
+function toSimpleYaml(obj, indent) {
+    if (indent === void 0) { indent = 0; }
     // Simple YAML serializer (for basic types)
     if (obj === null)
         return 'null';
@@ -679,22 +797,24 @@ function toSimpleYaml(obj, indent = 0) {
     if (typeof obj === 'number')
         return String(obj);
     if (typeof obj === 'string')
-        return obj.includes(':') ? `"${obj}"` : obj;
-    const spaces = '  '.repeat(indent);
-    let result = '';
+        return obj.includes(':') ? "\"" + obj + "\"" : obj;
+    var spaces = '  '.repeat(indent);
+    var result = '';
     if (Array.isArray(obj)) {
-        for (const item of obj) {
-            result += `${spaces}- ${toSimpleYaml(item, indent + 1).trim()}\n`;
+        for (var _i = 0, obj_1 = obj; _i < obj_1.length; _i++) {
+            var item = obj_1[_i];
+            result += spaces + "- " + toSimpleYaml(item, indent + 1).trim() + "\n";
         }
         return result;
     }
     if (typeof obj === 'object') {
-        for (const [key, value] of Object.entries(obj)) {
+        for (var _a = 0, _b = Object.entries(obj); _a < _b.length; _a++) {
+            var _c = _b[_a], key = _c[0], value = _c[1];
             if (typeof value === 'object' && value !== null) {
-                result += `${spaces}${key}:\n${toSimpleYaml(value, indent + 1)}`;
+                result += "" + spaces + key + ":\n" + toSimpleYaml(value, indent + 1);
             }
             else {
-                result += `${spaces}${key}: ${toSimpleYaml(value, indent)}\n`;
+                result += "" + spaces + key + ": " + toSimpleYaml(value, indent) + "\n";
             }
         }
         return result;
@@ -702,7 +822,7 @@ function toSimpleYaml(obj, indent = 0) {
     return String(obj);
 }
 // Main session command
-export const sessionCommand = {
+export var sessionCommand = {
     name: 'session',
     description: 'Session management commands',
     subcommands: [
@@ -724,27 +844,29 @@ export const sessionCommand = {
         { command: 'claude-flow session import backup.json', description: 'Import session from file' },
         { command: 'claude-flow session current', description: 'Show current session' }
     ],
-    action: async (ctx) => {
-        // Show help if no subcommand
-        output.writeln();
-        output.writeln(output.bold('Session Management Commands'));
-        output.writeln();
-        output.writeln('Usage: claude-flow session <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('list')}    - List all sessions`,
-            `${output.highlight('save')}    - Save current session state`,
-            `${output.highlight('restore')} - Restore a saved session`,
-            `${output.highlight('delete')}  - Delete a saved session`,
-            `${output.highlight('export')}  - Export session to file`,
-            `${output.highlight('import')}  - Import session from file`,
-            `${output.highlight('current')} - Show current active session`
-        ]);
-        output.writeln();
-        output.writeln('Run "claude-flow session <subcommand> --help" for subcommand help');
-        return { success: true };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            // Show help if no subcommand
+            output.writeln();
+            output.writeln(output.bold('Session Management Commands'));
+            output.writeln();
+            output.writeln('Usage: claude-flow session <subcommand> [options]');
+            output.writeln();
+            output.writeln('Subcommands:');
+            output.printList([
+                output.highlight('list') + "    - List all sessions",
+                output.highlight('save') + "    - Save current session state",
+                output.highlight('restore') + " - Restore a saved session",
+                output.highlight('delete') + "  - Delete a saved session",
+                output.highlight('export') + "  - Export session to file",
+                output.highlight('import') + "  - Import session from file",
+                output.highlight('current') + " - Show current active session"
+            ]);
+            output.writeln();
+            output.writeln('Run "claude-flow session <subcommand> --help" for subcommand help');
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default sessionCommand;
 //# sourceMappingURL=session.js.map