kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/claims.js

@@ -4,65 +4,9 @@
  *
  * Created with ❤️ by ruv.io
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { output } from '../output.js';
 // List subcommand
-var listCommand = {
+const listCommand = {
     name: 'list',
     description: 'List claims and permissions',
     options: [
@@ -74,35 +18,33 @@ var listCommand = {
         { command: 'claude-flow claims list', description: 'List all claims' },
         { command: 'claude-flow claims list -u user123', description: 'List user claims' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('Claims & Permissions'));
-            output.writeln(output.dim('─'.repeat(70)));
-            output.printTable({
-                columns: [
-                    { key: 'claim', header: 'Claim', width: 25 },
-                    { key: 'type', header: 'Type', width: 12 },
-                    { key: 'scope', header: 'Scope', width: 15 },
-                    { key: 'value', header: 'Value', width: 20 },
-                ],
-                data: [
-                    { claim: 'swarm:create', type: 'Permission', scope: 'Global', value: output.success('Allowed') },
-                    { claim: 'swarm:delete', type: 'Permission', scope: 'Owned', value: output.success('Allowed') },
-                    { claim: 'agent:spawn', type: 'Permission', scope: 'Global', value: output.success('Allowed') },
-                    { claim: 'memory:read', type: 'Permission', scope: 'Namespace', value: output.success('Allowed') },
-                    { claim: 'memory:write', type: 'Permission', scope: 'Namespace', value: output.success('Allowed') },
-                    { claim: 'admin:*', type: 'Permission', scope: 'Global', value: output.error('Denied') },
-                    { claim: 'role', type: 'Identity', scope: 'System', value: 'developer' },
-                    { claim: 'tier', type: 'Identity', scope: 'System', value: 'pro' },
-                ]
-            });
-            return [2 /*return*/, { success: true }];
+    action: async (ctx) => {
+        output.writeln();
+        output.writeln(output.bold('Claims & Permissions'));
+        output.writeln(output.dim('─'.repeat(70)));
+        output.printTable({
+            columns: [
+                { key: 'claim', header: 'Claim', width: 25 },
+                { key: 'type', header: 'Type', width: 12 },
+                { key: 'scope', header: 'Scope', width: 15 },
+                { key: 'value', header: 'Value', width: 20 },
+            ],
+            data: [
+                { claim: 'swarm:create', type: 'Permission', scope: 'Global', value: output.success('Allowed') },
+                { claim: 'swarm:delete', type: 'Permission', scope: 'Owned', value: output.success('Allowed') },
+                { claim: 'agent:spawn', type: 'Permission', scope: 'Global', value: output.success('Allowed') },
+                { claim: 'memory:read', type: 'Permission', scope: 'Namespace', value: output.success('Allowed') },
+                { claim: 'memory:write', type: 'Permission', scope: 'Namespace', value: output.success('Allowed') },
+                { claim: 'admin:*', type: 'Permission', scope: 'Global', value: output.error('Denied') },
+                { claim: 'role', type: 'Identity', scope: 'System', value: 'developer' },
+                { claim: 'tier', type: 'Identity', scope: 'System', value: 'pro' },
+            ],
         });
-    }); }
+        return { success: true };
+    },
 };
 // Check subcommand
-var checkCommand = {
+const checkCommand = {
     name: 'check',
     description: 'Check if a specific claim is granted',
     options: [
@@ -114,185 +56,168 @@ var checkCommand = {
         { command: 'claude-flow claims check -c swarm:create', description: 'Check swarm creation permission' },
         { command: 'claude-flow claims check -c admin:delete -u user123', description: 'Check user permission' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var claim, user, resource, spinner, fs, path, isGranted, reason, policySource, claimsConfigPaths, claimsConfig, _i, claimsConfigPaths_1, configPath, content, userConfig, userClaims, checkClaim;
-        var _a, _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    claim = ctx.flags.claim;
-                    user = ctx.flags.user || 'current';
-                    resource = ctx.flags.resource;
-                    if (!claim) {
-                        output.printError('Claim is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Claim Check'));
-                    output.writeln(output.dim('─'.repeat(40)));
-                    spinner = output.createSpinner({ text: 'Evaluating claim...', spinner: 'dots' });
-                    spinner.start();
-                    return [4 /*yield*/, import('fs')];
-                case 1:
-                    fs = _c.sent();
-                    return [4 /*yield*/, import('path')];
-                case 2:
-                    path = _c.sent();
-                    isGranted = false;
-                    reason = 'Claim not found in policy';
-                    policySource = 'default';
-                    try {
-                        claimsConfigPaths = [
-                            path.resolve('.claude-flow/claims.json'),
-                            path.resolve('claude-flow.claims.json'),
-                            path.resolve(process.env.HOME || '~', '.config/claude-flow/claims.json'),
-                        ];
-                        claimsConfig = {
-                            // Default policy - allows basic operations
-                            roles: {
-                                admin: ['*'],
-                                developer: ['swarm:*', 'agent:*', 'memory:*', 'task:*', 'session:*'],
-                                operator: ['swarm:status', 'agent:list', 'memory:read', 'task:list'],
-                                viewer: ['*:list', '*:status', '*:read']
-                            },
-                            defaultClaims: ['swarm:create', 'swarm:status', 'agent:spawn', 'agent:list', 'memory:read', 'memory:write', 'task:create']
-                        };
-                        for (_i = 0, claimsConfigPaths_1 = claimsConfigPaths; _i < claimsConfigPaths_1.length; _i++) {
-                            configPath = claimsConfigPaths_1[_i];
-                            if (fs.existsSync(configPath)) {
-                                content = fs.readFileSync(configPath, 'utf-8');
-                                claimsConfig = __assign(__assign({}, claimsConfig), JSON.parse(content));
-                                policySource = configPath;
-                                break;
-                            }
-                        }
-                        userConfig = (_a = claimsConfig.users) === null || _a === void 0 ? void 0 : _a[user];
-                        userClaims = __spreadArray([], (claimsConfig.defaultClaims || []), true);
-                        if (userConfig) {
-                            // Add user-specific claims
-                            if (userConfig.claims) {
-                                userClaims = __spreadArray(__spreadArray([], userClaims, true), userConfig.claims, true);
-                            }
-                            // Add role-based claims
-                            if (userConfig.role && ((_b = claimsConfig.roles) === null || _b === void 0 ? void 0 : _b[userConfig.role])) {
-                                userClaims = __spreadArray(__spreadArray([], userClaims, true), claimsConfig.roles[userConfig.role], true);
-                            }
-                        }
-                        checkClaim = function (claimToCheck, grantedClaims) {
-                            for (var _i = 0, grantedClaims_1 = grantedClaims; _i < grantedClaims_1.length; _i++) {
-                                var granted = grantedClaims_1[_i];
-                                // Exact match
-                                if (granted === claimToCheck)
-                                    return true;
-                                // Wildcard match (e.g., "swarm:*" matches "swarm:create")
-                                if (granted === '*')
-                                    return true;
-                                if (granted.endsWith(':*')) {
-                                    var prefix = granted.slice(0, -1);
-                                    if (claimToCheck.startsWith(prefix))
-                                        return true;
-                                }
-                                // Pattern match (e.g., "*:list" matches "swarm:list")
-                                if (granted.startsWith('*:')) {
-                                    var suffix = granted.slice(1);
-                                    if (claimToCheck.endsWith(suffix))
-                                        return true;
-                                }
-                            }
-                            return false;
-                        };
-                        isGranted = checkClaim(claim, userClaims);
-                        if (isGranted) {
-                            reason = (userConfig === null || userConfig === void 0 ? void 0 : userConfig.role)
-                                ? "Granted via role: " + userConfig.role
-                                : 'Granted via default policy';
-                        }
-                        else {
-                            reason = 'Not in user claims or role permissions';
-                        }
-                        spinner.stop();
-                    }
-                    catch (error) {
-                        spinner.stop();
-                        // On error, fall back to permissive default
-                        isGranted = !claim.startsWith('admin:');
-                        reason = isGranted ? 'Granted (default permissive policy)' : 'Admin claims require explicit grant';
-                        policySource = 'fallback';
-                    }
-                    if (isGranted) {
-                        output.writeln(output.success('✓ Claim granted'));
+    action: async (ctx) => {
+        const claim = ctx.flags.claim;
+        const user = ctx.flags.user || 'current';
+        const resource = ctx.flags.resource;
+        if (!claim) {
+            output.printError('Claim is required');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        output.writeln(output.bold('Claim Check'));
+        output.writeln(output.dim('─'.repeat(40)));
+        const spinner = output.createSpinner({ text: 'Evaluating claim...', spinner: 'dots' });
+        spinner.start();
+        const fs = await import('fs');
+        const path = await import('path');
+        // Real claims evaluation from config file
+        let isGranted = false;
+        let reason = 'Claim not found in policy';
+        let policySource = 'default';
+        try {
+            // Check for claims config file
+            const claimsConfigPaths = [
+                path.resolve('.claude-flow/claims.json'),
+                path.resolve('claude-flow.claims.json'),
+                path.resolve(process.env.HOME || '~', '.config/claude-flow/claims.json'),
+            ];
+            let claimsConfig = {
+                // Default policy - allows basic operations
+                roles: {
+                    admin: ['*'],
+                    developer: ['swarm:*', 'agent:*', 'memory:*', 'task:*', 'session:*'],
+                    operator: ['swarm:status', 'agent:list', 'memory:read', 'task:list'],
+                    viewer: ['*:list', '*:status', '*:read'],
+                },
+                defaultClaims: ['swarm:create', 'swarm:status', 'agent:spawn', 'agent:list', 'memory:read', 'memory:write', 'task:create'],
+            };
+            for (const configPath of claimsConfigPaths) {
+                if (fs.existsSync(configPath)) {
+                    const content = fs.readFileSync(configPath, 'utf-8');
+                    claimsConfig = { ...claimsConfig, ...JSON.parse(content) };
+                    policySource = configPath;
+                    break;
+                }
+            }
+            // Resolve user's claims
+            const userConfig = claimsConfig.users?.[user];
+            let userClaims = [...(claimsConfig.defaultClaims || [])];
+            if (userConfig) {
+                // Add user-specific claims
+                if (userConfig.claims) {
+                    userClaims = [...userClaims, ...userConfig.claims];
+                }
+                // Add role-based claims
+                if (userConfig.role && claimsConfig.roles?.[userConfig.role]) {
+                    userClaims = [...userClaims, ...claimsConfig.roles[userConfig.role]];
+                }
+            }
+            // Check if claim is granted
+            const checkClaim = (claimToCheck, grantedClaims) => {
+                for (const granted of grantedClaims) {
+                    // Exact match
+                    if (granted === claimToCheck)
+                        return true;
+                    // Wildcard match (e.g., "swarm:*" matches "swarm:create")
+                    if (granted === '*')
+                        return true;
+                    if (granted.endsWith(':*')) {
+                        const prefix = granted.slice(0, -1);
+                        if (claimToCheck.startsWith(prefix))
+                            return true;
                     }
-                    else {
-                        output.writeln(output.error('✗ Claim denied'));
+                    // Pattern match (e.g., "*:list" matches "swarm:list")
+                    if (granted.startsWith('*:')) {
+                        const suffix = granted.slice(1);
+                        if (claimToCheck.endsWith(suffix))
+                            return true;
                     }
-                    output.writeln();
-                    output.printBox([
-                        "Claim: " + claim,
-                        "User: " + user,
-                        "Resource: " + (resource || 'global'),
-                        "Result: " + (isGranted ? output.success('GRANTED') : output.error('DENIED')),
-                        "",
-                        "Reason: " + reason,
-                        "Policy: " + policySource,
-                    ].join('\n'), 'Result');
-                    return [2 /*return*/, { success: isGranted }];
+                }
+                return false;
+            };
+            isGranted = checkClaim(claim, userClaims);
+            if (isGranted) {
+                reason = userConfig?.role
+                    ? `Granted via role: ${userConfig.role}`
+                    : 'Granted via default policy';
             }
-        });
-    }); }
+            else {
+                reason = 'Not in user claims or role permissions';
+            }
+            spinner.stop();
+        }
+        catch (error) {
+            spinner.stop();
+            // On error, fall back to permissive default
+            isGranted = !claim.startsWith('admin:');
+            reason = isGranted ? 'Granted (default permissive policy)' : 'Admin claims require explicit grant';
+            policySource = 'fallback';
+        }
+        if (isGranted) {
+            output.writeln(output.success('✓ Claim granted'));
+        }
+        else {
+            output.writeln(output.error('✗ Claim denied'));
+        }
+        output.writeln();
+        output.printBox([
+            `Claim: ${claim}`,
+            `User: ${user}`,
+            `Resource: ${resource || 'global'}`,
+            `Result: ${isGranted ? output.success('GRANTED') : output.error('DENIED')}`,
+            ``,
+            `Reason: ${reason}`,
+            `Policy: ${policySource}`,
+        ].join('\n'), 'Result');
+        return { success: isGranted };
+    },
 };
 // Grant subcommand
-var grantCommand = {
+const grantCommand = {
     name: 'grant',
     description: 'Grant a claim to user or role',
     options: [
         { name: 'claim', short: 'c', type: 'string', description: 'Claim to grant', required: true },
         { name: 'user', short: 'u', type: 'string', description: 'User ID' },
         { name: 'role', short: 'r', type: 'string', description: 'Role name' },
-        { name: 'scope', short: 's', type: 'string', description: 'Scope: global, namespace, resource', "default": 'global' },
+        { name: 'scope', short: 's', type: 'string', description: 'Scope: global, namespace, resource', default: 'global' },
         { name: 'expires', short: 'e', type: 'string', description: 'Expiration time (e.g., 24h, 7d)' },
     ],
     examples: [
         { command: 'claude-flow claims grant -c swarm:create -u user123', description: 'Grant to user' },
         { command: 'claude-flow claims grant -c agent:spawn -r developer', description: 'Grant to role' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var claim, user, role, scope, spinner;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    claim = ctx.flags.claim;
-                    user = ctx.flags.user;
-                    role = ctx.flags.role;
-                    scope = ctx.flags.scope || 'global';
-                    if (!claim) {
-                        output.printError('Claim is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (!user && !role) {
-                        output.printError('Either user or role is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    spinner = output.createSpinner({ text: 'Granting claim...', spinner: 'dots' });
-                    spinner.start();
-                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 400); })];
-                case 1:
-                    _a.sent();
-                    spinner.succeed('Claim granted');
-                    output.writeln();
-                    output.printBox([
-                        "Claim: " + claim,
-                        "Target: " + (user ? "User: " + user : "Role: " + role),
-                        "Scope: " + scope,
-                        "Status: " + output.success('Active'),
-                    ].join('\n'), 'Grant Complete');
-                    return [2 /*return*/, { success: true }];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const claim = ctx.flags.claim;
+        const user = ctx.flags.user;
+        const role = ctx.flags.role;
+        const scope = ctx.flags.scope || 'global';
+        if (!claim) {
+            output.printError('Claim is required');
+            return { success: false, exitCode: 1 };
+        }
+        if (!user && !role) {
+            output.printError('Either user or role is required');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Granting claim...', spinner: 'dots' });
+        spinner.start();
+        await new Promise(r => setTimeout(r, 400));
+        spinner.succeed('Claim granted');
+        output.writeln();
+        output.printBox([
+            `Claim: ${claim}`,
+            `Target: ${user ? `User: ${user}` : `Role: ${role}`}`,
+            `Scope: ${scope}`,
+            `Status: ${output.success('Active')}`,
+        ].join('\n'), 'Grant Complete');
+        return { success: true };
+    },
 };
 // Revoke subcommand
-var revokeCommand = {
+const revokeCommand = {
     name: 'revoke',
     description: 'Revoke a claim from user or role',
     options: [
@@ -304,124 +229,111 @@ var revokeCommand = {
         { command: 'claude-flow claims revoke -c swarm:delete -u user123', description: 'Revoke from user' },
         { command: 'claude-flow claims revoke -c admin:* -r guest', description: 'Revoke from role' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var claim, user, role, spinner;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    claim = ctx.flags.claim;
-                    user = ctx.flags.user;
-                    role = ctx.flags.role;
-                    if (!claim) {
-                        output.printError('Claim is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    spinner = output.createSpinner({ text: 'Revoking claim...', spinner: 'dots' });
-                    spinner.start();
-                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 300); })];
-                case 1:
-                    _a.sent();
-                    spinner.succeed('Claim revoked');
-                    return [2 /*return*/, { success: true }];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const claim = ctx.flags.claim;
+        const user = ctx.flags.user;
+        const role = ctx.flags.role;
+        if (!claim) {
+            output.printError('Claim is required');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Revoking claim...', spinner: 'dots' });
+        spinner.start();
+        await new Promise(r => setTimeout(r, 300));
+        spinner.succeed('Claim revoked');
+        return { success: true };
+    },
 };
 // Roles subcommand
-var rolesCommand = {
+const rolesCommand = {
     name: 'roles',
     description: 'Manage roles and their claims',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: list, create, delete, show', "default": 'list' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: list, create, delete, show', default: 'list' },
         { name: 'name', short: 'n', type: 'string', description: 'Role name' },
     ],
     examples: [
         { command: 'claude-flow claims roles', description: 'List all roles' },
         { command: 'claude-flow claims roles -a show -n admin', description: 'Show role details' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var action, name;
-        return __generator(this, function (_a) {
-            action = ctx.flags.action || 'list';
-            name = ctx.flags.name;
-            output.writeln();
-            output.writeln(output.bold('Roles'));
-            output.writeln(output.dim('─'.repeat(60)));
-            if (action === 'show' && name) {
-                output.printBox([
-                    "Role: " + name,
-                    "Description: Full system access",
-                    "",
-                    "Claims:",
-                    "  - swarm:* (all swarm operations)",
-                    "  - agent:* (all agent operations)",
-                    "  - memory:* (all memory operations)",
-                    "  - admin:* (administrative functions)",
-                    "",
-                    "Members: 2",
-                    "Created: 2024-01-01",
-                ].join('\n'), 'Role Details');
-            }
-            else {
-                output.printTable({
-                    columns: [
-                        { key: 'role', header: 'Role', width: 15 },
-                        { key: 'description', header: 'Description', width: 30 },
-                        { key: 'claims', header: 'Claims', width: 12 },
-                        { key: 'members', header: 'Members', width: 10 },
-                    ],
-                    data: [
-                        { role: output.highlight('admin'), description: 'Full system access', claims: '15', members: '2' },
-                        { role: output.highlight('developer'), description: 'Development operations', claims: '10', members: '12' },
-                        { role: output.highlight('operator'), description: 'Operational tasks', claims: '8', members: '5' },
-                        { role: output.highlight('viewer'), description: 'Read-only access', claims: '3', members: '25' },
-                        { role: output.highlight('guest'), description: 'Limited access', claims: '1', members: '100' },
-                    ]
-                });
-            }
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'list';
+        const name = ctx.flags.name;
+        output.writeln();
+        output.writeln(output.bold('Roles'));
+        output.writeln(output.dim('─'.repeat(60)));
+        if (action === 'show' && name) {
+            output.printBox([
+                `Role: ${name}`,
+                `Description: Full system access`,
+                ``,
+                `Claims:`,
+                `  - swarm:* (all swarm operations)`,
+                `  - agent:* (all agent operations)`,
+                `  - memory:* (all memory operations)`,
+                `  - admin:* (administrative functions)`,
+                ``,
+                `Members: 2`,
+                `Created: 2024-01-01`,
+            ].join('\n'), 'Role Details');
+        }
+        else {
+            output.printTable({
+                columns: [
+                    { key: 'role', header: 'Role', width: 15 },
+                    { key: 'description', header: 'Description', width: 30 },
+                    { key: 'claims', header: 'Claims', width: 12 },
+                    { key: 'members', header: 'Members', width: 10 },
+                ],
+                data: [
+                    { role: output.highlight('admin'), description: 'Full system access', claims: '15', members: '2' },
+                    { role: output.highlight('developer'), description: 'Development operations', claims: '10', members: '12' },
+                    { role: output.highlight('operator'), description: 'Operational tasks', claims: '8', members: '5' },
+                    { role: output.highlight('viewer'), description: 'Read-only access', claims: '3', members: '25' },
+                    { role: output.highlight('guest'), description: 'Limited access', claims: '1', members: '100' },
+                ],
+            });
+        }
+        return { success: true };
+    },
 };
 // Policies subcommand
-var policiesCommand = {
+const policiesCommand = {
     name: 'policies',
     description: 'Manage claim policies',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: list, create, delete', "default": 'list' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: list, create, delete', default: 'list' },
         { name: 'name', short: 'n', type: 'string', description: 'Policy name' },
     ],
     examples: [
         { command: 'claude-flow claims policies', description: 'List policies' },
         { command: 'claude-flow claims policies -a create -n rate-limit', description: 'Create policy' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('Claim Policies'));
-            output.writeln(output.dim('─'.repeat(60)));
-            output.printTable({
-                columns: [
-                    { key: 'policy', header: 'Policy', width: 20 },
-                    { key: 'type', header: 'Type', width: 15 },
-                    { key: 'condition', header: 'Condition', width: 30 },
-                    { key: 'status', header: 'Status', width: 12 },
-                ],
-                data: [
-                    { policy: 'rate-limit', type: 'Throttle', condition: 'Max 100 req/min', status: output.success('Active') },
-                    { policy: 'geo-restrict', type: 'Location', condition: 'US, EU only', status: output.success('Active') },
-                    { policy: 'time-window', type: 'Temporal', condition: 'Business hours', status: output.dim('Inactive') },
-                    { policy: 'ip-allowlist', type: 'Network', condition: '10.0.0.0/8', status: output.success('Active') },
-                    { policy: 'mfa-required', type: 'Auth', condition: 'Admin operations', status: output.success('Active') },
-                ]
-            });
-            return [2 /*return*/, { success: true }];
+    action: async (ctx) => {
+        output.writeln();
+        output.writeln(output.bold('Claim Policies'));
+        output.writeln(output.dim('─'.repeat(60)));
+        output.printTable({
+            columns: [
+                { key: 'policy', header: 'Policy', width: 20 },
+                { key: 'type', header: 'Type', width: 15 },
+                { key: 'condition', header: 'Condition', width: 30 },
+                { key: 'status', header: 'Status', width: 12 },
+            ],
+            data: [
+                { policy: 'rate-limit', type: 'Throttle', condition: 'Max 100 req/min', status: output.success('Active') },
+                { policy: 'geo-restrict', type: 'Location', condition: 'US, EU only', status: output.success('Active') },
+                { policy: 'time-window', type: 'Temporal', condition: 'Business hours', status: output.dim('Inactive') },
+                { policy: 'ip-allowlist', type: 'Network', condition: '10.0.0.0/8', status: output.success('Active') },
+                { policy: 'mfa-required', type: 'Auth', condition: 'Admin operations', status: output.success('Active') },
+            ],
         });
-    }); }
+        return { success: true };
+    },
 };
 // Main claims command
-export var claimsCommand = {
+export const claimsCommand = {
     name: 'claims',
     description: 'Claims-based authorization, permissions, and access control',
     subcommands: [listCommand, checkCommand, grantCommand, revokeCommand, rolesCommand, policiesCommand],
@@ -430,34 +342,32 @@ export var claimsCommand = {
         { command: 'claude-flow claims check -c swarm:create', description: 'Check permission' },
         { command: 'claude-flow claims grant -c agent:spawn -r developer', description: 'Grant claim' },
     ],
-    action: function () { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('RuFlo Claims System'));
-            output.writeln(output.dim('Fine-grained authorization and access control'));
-            output.writeln();
-            output.writeln('Subcommands:');
-            output.printList([
-                'list     - List claims and permissions',
-                'check    - Check if a claim is granted',
-                'grant    - Grant a claim to user or role',
-                'revoke   - Revoke a claim',
-                'roles    - Manage roles and their claims',
-                'policies - Manage claim policies',
-            ]);
-            output.writeln();
-            output.writeln('Claim Types:');
-            output.printList([
-                'swarm:*   - Swarm operations (create, delete, scale)',
-                'agent:*   - Agent operations (spawn, terminate)',
-                'memory:*  - Memory operations (read, write, delete)',
-                'admin:*   - Administrative operations',
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Created with ❤️ by ruv.io'));
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('RuFlo Claims System'));
+        output.writeln(output.dim('Fine-grained authorization and access control'));
+        output.writeln();
+        output.writeln('Subcommands:');
+        output.printList([
+            'list     - List claims and permissions',
+            'check    - Check if a claim is granted',
+            'grant    - Grant a claim to user or role',
+            'revoke   - Revoke a claim',
+            'roles    - Manage roles and their claims',
+            'policies - Manage claim policies',
+        ]);
+        output.writeln();
+        output.writeln('Claim Types:');
+        output.printList([
+            'swarm:*   - Swarm operations (create, delete, scale)',
+            'agent:*   - Agent operations (spawn, terminate)',
+            'memory:*  - Memory operations (read, write, delete)',
+            'admin:*   - Administrative operations',
+        ]);
+        output.writeln();
+        output.writeln(output.dim('Created with ❤️ by ruv.io'));
+        return { success: true };
+    },
 };
 export default claimsCommand;
 //# sourceMappingURL=claims.js.map