kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/claims.js

@@ -4,9 +4,65 @@
  *
  * 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
-const listCommand = {
+var listCommand = {
     name: 'list',
     description: 'List claims and permissions',
     options: [
@@ -18,33 +74,35 @@ const listCommand = {
         { command: 'claude-flow claims list', description: 'List all claims' },
         { command: 'claude-flow claims list -u user123', description: 'List user claims' },
     ],
-    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' },
-            ],
+    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 }];
         });
-        return { success: true };
-    },
+    }); }
 };
 // Check subcommand
-const checkCommand = {
+var checkCommand = {
     name: 'check',
     description: 'Check if a specific claim is granted',
     options: [
@@ -56,168 +114,185 @@ const 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: 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;
+    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 }];
                     }
-                    // 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.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();
                     }
-                }
-                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';
+                    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 [2 /*return*/, { success: isGranted }];
             }
-            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
-const grantCommand = {
+var 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: 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 };
-    },
+    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 }];
+            }
+        });
+    }); }
 };
 // Revoke subcommand
-const revokeCommand = {
+var revokeCommand = {
     name: 'revoke',
     description: 'Revoke a claim from user or role',
     options: [
@@ -229,111 +304,124 @@ const 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: 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 };
-    },
+    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 }];
+            }
+        });
+    }); }
 };
 // Roles subcommand
-const rolesCommand = {
+var 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: 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 };
-    },
+    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 }];
+        });
+    }); }
 };
 // Policies subcommand
-const policiesCommand = {
+var 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: 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') },
-            ],
+    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 }];
         });
-        return { success: true };
-    },
+    }); }
 };
 // Main claims command
-export const claimsCommand = {
+export var claimsCommand = {
     name: 'claims',
     description: 'Claims-based authorization, permissions, and access control',
     subcommands: [listCommand, checkCommand, grantCommand, revokeCommand, rolesCommand, policiesCommand],
@@ -342,32 +430,34 @@ export const 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: async () => {
-        output.writeln();
-        output.writeln(output.bold('KynjalFlow 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 };
-    },
+    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 }];
+        });
+    }); }
 };
 export default claimsCommand;
 //# sourceMappingURL=claims.js.map