synapse 2.171.0__py311-none-any.whl → 2.173.1__py311-none-any.whl

synapse/lib/layer.py

@@ -75,6 +75,7 @@ import synapse.telepath as s_telepath
 
 import synapse.lib.gis as s_gis
 import synapse.lib.cell as s_cell
+import synapse.lib.coro as s_coro
 import synapse.lib.cache as s_cache
 import synapse.lib.nexus as s_nexus
 import synapse.lib.queue as s_queue
@@ -157,14 +158,14 @@ class LayerApi(s_cell.CellApi):
 
         await self.layr.storNodeEditsNoLift(nodeedits, meta)
 
-    async def syncNodeEdits(self, offs, wait=True):
+    async def syncNodeEdits(self, offs, wait=True, reverse=False):
         '''
         Yield (offs, nodeedits) tuples from the nodeedit log starting from the given offset.
 
         Once caught up with storage, yield them in realtime.
         '''
         await self._reqUserAllowed(self.liftperm)
-        async for item in self.layr.syncNodeEdits(offs, wait=wait):
+        async for item in self.layr.syncNodeEdits(offs, wait=wait, reverse=reverse):
             yield item
             await asyncio.sleep(0)
 
@@ -3816,7 +3817,7 @@ class Layer(s_nexus.Pusher):
 
     async def getEdgeVerbs(self):
 
-        for lkey in self.layrslab.scanKeys(db=self.byverb):
+        for lkey in self.layrslab.scanKeys(db=self.byverb, nodup=True):
             yield lkey.decode()
 
     async def getEdges(self, verb=None):
@@ -4088,11 +4089,126 @@ class Layer(s_nexus.Pusher):
         '''
         Return a generator of all a buid's node data keys
         '''
-        for lkey in self.dataslab.scanKeysByPref(buid, db=self.nodedata):
+        for lkey in self.dataslab.scanKeysByPref(buid, db=self.nodedata, nodup=True):
             abrv = lkey[32:]
             prop = self.getAbrvProp(abrv)
             yield prop[0]
 
+    async def confirmLayerEditPerms(self, user, gateiden, delete=False):
+        if delete:
+            perm_forms = ('node', 'del')
+            perm_props = ('node', 'prop', 'del')
+            perm_tags = ('node', 'tag', 'del')
+            perm_ndata = ('node', 'data', 'pop')
+            perm_edges = ('node', 'edge', 'del')
+        else:
+            perm_forms = ('node', 'add')
+            perm_props = ('node', 'prop', 'set')
+            perm_tags = ('node', 'tag', 'add')
+            perm_ndata = ('node', 'data', 'set')
+            perm_edges = ('node', 'edge', 'add')
+
+        if user.allowed(('node',), gateiden=gateiden, deepdeny=True):
+            return
+
+        allow_forms = user.allowed(perm_forms, gateiden=gateiden, deepdeny=True)
+        allow_props = user.allowed(perm_props, gateiden=gateiden, deepdeny=True)
+        allow_tags = user.allowed(perm_tags, gateiden=gateiden, deepdeny=True)
+        allow_ndata = user.allowed(perm_ndata, gateiden=gateiden, deepdeny=True)
+        allow_edges = user.allowed(perm_edges, gateiden=gateiden, deepdeny=True)
+
+        if all((allow_forms, allow_props, allow_tags, allow_ndata, allow_edges)):
+            return
+
+        # nodes & props
+        if not allow_forms or not allow_props:
+            async for byts, abrv in s_coro.pause(self.propabrv.slab.scanByFull(db=self.propabrv.name2abrv)):
+                form, prop = s_msgpack.un(byts)
+                if form is None: # pragma: no cover
+                    continue
+
+                if self.layrslab.prefexists(abrv, db=self.byprop):
+                    if prop and not allow_props:
+                        realform = self.core.model.form(form)
+                        if not realform: # pragma: no cover
+                            mesg = f'Invalid form: {form}'
+                            raise s_exc.NoSuchForm(mesg=mesg, form=form)
+
+                        realprop = realform.prop(prop)
+                        if not realprop: # pragma: no cover
+                            mesg = f'Invalid prop: {form}:{prop}'
+                            raise s_exc.NoSuchProp(mesg=mesg, form=form, prop=prop)
+
+                        if delete:
+                            self.core.confirmPropDel(user, realprop, gateiden)
+                        else:
+                            self.core.confirmPropSet(user, realprop, gateiden)
+
+                    elif not prop and not allow_forms:
+                        user.confirm(perm_forms + (form,), gateiden=gateiden)
+
+        # tagprops
+        if not allow_tags:
+            async for byts, abrv in s_coro.pause(self.tagpropabrv.slab.scanByFull(db=self.tagpropabrv.name2abrv)):
+                info = s_msgpack.un(byts)
+                if None in info or len(info) != 3:
+                    continue
+
+                if self.layrslab.prefexists(abrv, db=self.bytagprop):
+                    perm = perm_tags + tuple(info[1].split('.'))
+                    user.confirm(perm, gateiden=gateiden)
+
+        # nodedata
+        if not allow_ndata:
+            async for abrv in s_coro.pause(self.dataslab.scanKeys(db=self.dataname, nodup=True)):
+                name, _ = self.getAbrvProp(abrv)
+                perm = perm_ndata + (name,)
+                user.confirm(perm, gateiden=gateiden)
+
+        # edges
+        if not allow_edges:
+            async for verb in s_coro.pause(self.layrslab.scanKeys(db=self.byverb, nodup=True)):
+                perm = perm_edges + (verb.decode(),)
+                user.confirm(perm, gateiden=gateiden)
+
+        # tags
+        # NB: tag perms should be yielded for every leaf on every node in the layer
+        if not allow_tags:
+            async with self.core.getSpooledDict() as tags:
+
+                # Collect all tag abrvs for all nodes in the layer
+                async for lkey, buid in s_coro.pause(self.layrslab.scanByFull(db=self.bytag)):
+                    abrv = lkey[:8]
+                    abrvs = list(tags.get(buid, []))
+                    abrvs.append(abrv)
+                    await tags.set(buid, abrvs)
+
+                # Iterate over each node and it's tags
+                async for buid, abrvs in s_coro.pause(tags.items()):
+                    seen = {}
+
+                    if len(abrvs) == 1:
+                        # Easy optimization: If there's only one tag abrv, then it's a
+                        # leaf by default
+                        name = self.tagabrv.abrvToName(abrv)
+                        key = tuple(name.split('.'))
+                        perm = perm_tags + key
+                        user.confirm(perm, gateiden=gateiden)
+
+                    else:
+                        for abrv in abrvs:
+                            name = self.tagabrv.abrvToName(abrv)
+                            parts = tuple(name.split('.'))
+                            for idx in range(1, len(parts) + 1):
+                                key = tuple(parts[:idx])
+                                seen.setdefault(key, 0)
+                                seen[key] += 1
+
+                        for key, count in seen.items():
+                            if count == 1:
+                                perm = perm_tags + key
+                                user.confirm(perm, gateiden=gateiden)
+
     async def iterLayerNodeEdits(self):
         '''
         Scan the full layer and yield artificial sets of nodeedits.
@@ -4291,7 +4407,7 @@ class Layer(s_nexus.Pusher):
         for offs, (edits, meta) in self.nodeeditlog.iterBack(offs):
             yield (offs, edits, meta)
 
-    async def syncNodeEdits2(self, offs, wait=True):
+    async def syncNodeEdits2(self, offs, wait=True, reverse=False):
         '''
         Once caught up with storage, yield them in realtime.
 
@@ -4301,7 +4417,7 @@ class Layer(s_nexus.Pusher):
         if not self.logedits:
             return
 
-        for offi, (nodeedits, meta) in self.nodeeditlog.iter(offs):
+        for offi, (nodeedits, meta) in self.nodeeditlog.iter(offs, reverse=reverse):
             yield (offi, nodeedits, meta)
 
         if wait:
@@ -4309,11 +4425,11 @@ class Layer(s_nexus.Pusher):
                 async for item in wind:
                     yield item
 
-    async def syncNodeEdits(self, offs, wait=True):
+    async def syncNodeEdits(self, offs, wait=True, reverse=False):
         '''
         Identical to syncNodeEdits2, but doesn't yield meta
         '''
-        async for offi, nodeedits, _meta in self.syncNodeEdits2(offs, wait=wait):
+        async for offi, nodeedits, _meta in self.syncNodeEdits2(offs, wait=wait, reverse=reverse):
             yield (offi, nodeedits)
 
     async def syncIndexEvents(self, offs, matchdef, wait=True):
@@ -4450,79 +4566,3 @@ def getFlatEdits(nodeedits):
         addedits(buid, form, edits)
 
     return [(k[0], k[1], v) for (k, v) in editsbynode.items()]
-
-def getNodeEditPerms(nodeedits):
-    '''
-    Yields (offs, perm) tuples that can be used in user.allowed()
-    '''
-    tags = []
-    tagadds = []
-
-    for nodeoffs, (buid, form, edits) in enumerate(nodeedits):
-
-        tags.clear()
-        tagadds.clear()
-
-        for editoffs, (edit, info, _) in enumerate(edits):
-
-            permoffs = (nodeoffs, editoffs)
-
-            if edit == EDIT_NODE_ADD:
-                yield (permoffs, ('node', 'add', form))
-                continue
-
-            if edit == EDIT_NODE_DEL:
-                yield (permoffs, ('node', 'del', form))
-                continue
-
-            if edit == EDIT_PROP_SET:
-                yield (permoffs, ('node', 'prop', 'set', f'{form}:{info[0]}'))
-                continue
-
-            if edit == EDIT_PROP_DEL:
-                yield (permoffs, ('node', 'prop', 'del', f'{form}:{info[0]}'))
-                continue
-
-            if edit == EDIT_TAG_SET:
-                if info[1] != (None, None):
-                    tagadds.append(info[0])
-                    yield (permoffs, ('node', 'tag', 'add', *info[0].split('.')))
-                else:
-                    tags.append((len(info[0]), editoffs, info[0]))
-                continue
-
-            if edit == EDIT_TAG_DEL:
-                yield (permoffs, ('node', 'tag', 'del', *info[0].split('.')))
-                continue
-
-            if edit == EDIT_TAGPROP_SET:
-                yield (permoffs, ('node', 'tag', 'add', *info[0].split('.')))
-                continue
-
-            if edit == EDIT_TAGPROP_DEL:
-                yield (permoffs, ('node', 'tag', 'del', *info[0].split('.')))
-                continue
-
-            if edit == EDIT_NODEDATA_SET:
-                yield (permoffs, ('node', 'data', 'set', info[0]))
-                continue
-
-            if edit == EDIT_NODEDATA_DEL:
-                yield (permoffs, ('node', 'data', 'pop', info[0]))
-                continue
-
-            if edit == EDIT_EDGE_ADD:
-                yield (permoffs, ('node', 'edge', 'add', info[0]))
-                continue
-
-            if edit == EDIT_EDGE_DEL:
-                yield (permoffs, ('node', 'edge', 'del', info[0]))
-                continue
-
-        for _, editoffs, tag in sorted(tags, reverse=True):
-            look = tag + '.'
-            if any([tagadd.startswith(look) for tagadd in tagadds]):
-                continue
-
-            yield ((nodeoffs, editoffs), ('node', 'tag', 'add', *tag.split('.')))
-            tagadds.append(tag)

synapse/lib/lmdbslab.py

@@ -1253,18 +1253,18 @@ class Slab(s_base.Base):
         finally:
             self._relXactForReading()
 
-    def scanKeys(self, db=None):
+    def scanKeys(self, db=None, nodup=False):
 
-        with ScanKeys(self, db) as scan:
+        with ScanKeys(self, db, nodup=nodup) as scan:
 
             if not scan.first():
                 return
 
             yield from scan.iternext()
 
-    def scanKeysByPref(self, byts, db=None):
+    def scanKeysByPref(self, byts, db=None, nodup=False):
 
-        with ScanKeys(self, db) as scan:
+        with ScanKeys(self, db, nodup=nodup) as scan:
 
             if not scan.set_range(byts):
                 return
@@ -1283,7 +1283,7 @@ class Slab(s_base.Base):
         '''
         count = 0
         size = len(byts)
-        with ScanKeys(self, db) as scan:
+        with ScanKeys(self, db, nodup=True) as scan:
 
             if not scan.set_range(byts):
                 return 0
@@ -1293,7 +1293,7 @@ class Slab(s_base.Base):
                 if lkey[:size] != byts:
                     return count
 
-                count += 1
+                count += scan.curs.count()
                 if maxsize is not None and maxsize == count:
                     return count
 
@@ -1756,14 +1756,21 @@ class ScanKeys(Scan):
     An iterator over the keys of the database.  If the database is dupsort, a key with multiple values with be yielded
     once for each value.
     '''
+    def __init__(self, slab, db, nodup=False):
+        Scan.__init__(self, slab, db)
+        self.nodup = nodup
+
     def iterfunc(self):
         if self.dupsort:
-            return Scan.iterfunc(self)
+            if self.nodup:
+                return self.curs.iternext_nodup(keys=True, values=False)
+            else:
+                return Scan.iterfunc(self)
 
         return self.curs.iternext(keys=True, values=False)
 
     def resume(self):
-        if self.dupsort:
+        if self.dupsort and not self.nodup:
             return Scan.resume(self)
 
         return self.curs.set_range(self.atitem)
@@ -1772,13 +1779,13 @@ class ScanKeys(Scan):
         '''
         Returns if the cursor is at the value in atitem
         '''
-        if self.dupsort:
+        if self.dupsort and not self.nodup:
             return Scan.isatitem(self)
 
         return self.atitem == self.curs.key()
 
     def iternext(self):
-        if self.dupsort:
+        if self.dupsort and not self.nodup:
             yield from (item[0] for item in Scan.iternext(self))
             return
 

synapse/lib/node.py

@@ -270,7 +270,7 @@ class Node:
 
         if self.form.isrunt:
             if prop.info.get('ro'):
-                mesg = f'Cannot set read-only props on runt nodes: {repr(valu)[:256]}'
+                mesg = f'Cannot set read-only props on runt nodes: {s_common.trimText(repr(valu))}'
                 raise s_exc.IsRuntForm(mesg=mesg, form=self.form.full, prop=name)
 
             await self.snap.core.runRuntPropSet(self, prop, valu)

synapse/lib/slabseqn.py

@@ -169,7 +169,7 @@ class SlabSeqn:
 
         return s_common.int64un(byts) + 1
 
-    def iter(self, offs):
+    def iter(self, offs, reverse=False):
         '''
         Iterate over items in a sequence from a given offset.
 
@@ -180,10 +180,16 @@ class SlabSeqn:
             (indx, valu): The index and valu of the item.
         '''
         startkey = s_common.int64en(offs)
-        for lkey, lval in self.slab.scanByRange(startkey, db=self.db):
-            offs = s_common.int64un(lkey)
-            valu = s_msgpack.un(lval)
-            yield offs, valu
+        if reverse:
+            for lkey, lval in self.slab.scanByRangeBack(startkey, db=self.db):
+                offs = s_common.int64un(lkey)
+                valu = s_msgpack.un(lval)
+                yield offs, valu
+        else:
+            for lkey, lval in self.slab.scanByRange(startkey, db=self.db):
+                offs = s_common.int64un(lkey)
+                valu = s_msgpack.un(lval)
+                yield offs, valu
 
     async def aiter(self, offs, wait=False, timeout=None):
         '''

synapse/lib/storm.py

@@ -2195,92 +2195,28 @@ class Runtime(s_base.Base):
         return self.user.allowed(perms, gateiden=gateiden, default=default)
 
     def allowedReason(self, perms, gateiden=None, default=None):
-        '''
-        Similar to allowed, but always prefer the default value specified by the caller.
-        Default values are still pulled from permdefs if there is a match there; but still prefer caller default.
-        This results in a ternary response that can be used to know if a rule had a positive/negative or no match.
-        The matching reason metadata is also returned.
-        '''
         if self.asroot:
             return self._admin_reason
 
-        if default is None:
-            permdef = self.snap.core.getPermDef(perms)
-            if permdef:
-                default = permdef.get('default', default)
-
-        return self.user.getAllowedReason(perms, gateiden=gateiden, default=default)
+        return self.snap.core._propAllowedReason(self.user, perms, gateiden=gateiden, default=default)
 
     def confirmPropSet(self, prop, layriden=None):
+        if self.asroot:
+            return
 
         if layriden is None:
             layriden = self.snap.wlyr.iden
 
-        meta0 = self.allowedReason(prop.setperms[0], gateiden=layriden)
-
-        if meta0.isadmin:
-            return
-
-        allowed0 = meta0.value
-
-        meta1 = self.allowedReason(prop.setperms[1], gateiden=layriden)
-        allowed1 = meta1.value
-
-        if allowed0:
-            if allowed1:
-                return
-            elif allowed1 is False:
-                # This is a allow-with-precedence case.
-                # Inspect meta to determine if the rule a0 is more specific than rule a1
-                if len(meta0.rule) >= len(meta1.rule):
-                    return
-                self.user.raisePermDeny(prop.setperms[0], gateiden=layriden)
-            return
-
-        if allowed1:
-            if allowed0 is None:
-                return
-            # allowed0 here is False. This is a deny-with-precedence case.
-            # Inspect meta to determine if the rule a1 is more specific than rule a0
-            if len(meta1.rule) > len(meta0.rule):
-                return
-
-        self.user.raisePermDeny(prop.setperms[0], gateiden=layriden)
+        return self.snap.core.confirmPropSet(self.user, prop, layriden=layriden)
 
     def confirmPropDel(self, prop, layriden=None):
+        if self.asroot:
+            return
 
         if layriden is None:
             layriden = self.snap.wlyr.iden
 
-        meta0 = self.allowedReason(prop.delperms[0], gateiden=layriden)
-
-        if meta0.isadmin:
-            return
-
-        allowed0 = meta0.value
-        meta1 = self.allowedReason(prop.delperms[1], gateiden=layriden)
-        allowed1 = meta1.value
-
-        if allowed0:
-            if allowed1:
-                return
-            elif allowed1 is False:
-                # This is a allow-with-precedence case.
-                # Inspect meta to determine if the rule a0 is more specific than rule a1
-                if len(meta0.rule) >= len(meta1.rule):
-                    return
-                self.user.raisePermDeny(prop.delperms[0], gateiden=layriden)
-            return
-
-        if allowed1:
-            if allowed0 is None:
-                return
-            # allowed0 here is False. This is a deny-with-precedence case.
-            # Inspect meta to determine if the rule a1 is more specific than rule a0
-            if len(meta1.rule) > len(meta0.rule):
-                return
-
-        self.user.raisePermDeny(prop.delperms[0], gateiden=layriden)
+        return self.snap.core.confirmPropDel(self.user, prop, layriden=layriden)
 
     def confirmEasyPerm(self, item, perm, mesg=None):
         if not self.asroot:

synapse/lib/stormhttp.py

@@ -549,7 +549,7 @@ class HttpResp(s_stormtypes.Prim):
             return json.loads(valu.decode(encoding, errors))
 
         except UnicodeDecodeError as e:
-            raise s_exc.StormRuntimeError(mesg=f'{e}: {repr(valu)[:256]}') from None
+            raise s_exc.StormRuntimeError(mesg=f'{e}: {s_common.trimText(repr(valu))}') from None
 
         except json.JSONDecodeError as e:
             mesg = f'Unable to decode HTTP response as json: {e.args[0]}'

synapse/lib/stormlib/auth.py

@@ -959,6 +959,18 @@ class User(s_stormtypes.Prim):
                       {'name': 'locked', 'type': 'boolean', 'desc': 'True to lock the user, false to unlock them.', },
                   ),
                   'returns': {'type': 'null', }}},
+        {'name': 'setArchived', 'desc': '''
+        Set the archived status for a user.
+
+        Notes:
+            Setting a user as "archived" will also lock the user.
+            Removing a users "archived" status will not unlock the user.
+        ''',
+         'type': {'type': 'function', '_funcname': '_methUserSetArchived',
+                  'args': (
+                      {'name': 'archived', 'type': 'boolean', 'desc': 'True to archive the user, false to unarchive them.', },
+                  ),
+                  'returns': {'type': 'null', }}},
         {'name': 'setPasswd', 'desc': 'Set the Users password.',
          'type': {'type': 'function', '_funcname': '_methUserSetPasswd',
                   'args': (
@@ -1113,6 +1125,7 @@ class User(s_stormtypes.Prim):
             'setEmail': self._methUserSetEmail,
             'setLocked': self._methUserSetLocked,
             'setPasswd': self._methUserSetPasswd,
+            'setArchived': self._methUserSetArchived,
             'getAllowedReason': self._methGetAllowedReason,
             'genApiKey': self._methGenApiKey,
             'getApiKey': self._methGetApiKey,
@@ -1286,6 +1299,10 @@ class User(s_stormtypes.Prim):
         self.runt.confirm(('auth', 'user', 'set', 'locked'))
         await self.runt.snap.core.setUserLocked(self.valu, await s_stormtypes.tobool(locked))
 
+    async def _methUserSetArchived(self, archived):
+        self.runt.confirm(('auth', 'user', 'set', 'archived'))
+        await self.runt.snap.core.setUserArchived(self.valu, await s_stormtypes.tobool(archived))
+
     async def _methGenApiKey(self, name, duration=None):
         name = await s_stormtypes.tostr(name)
         duration = await s_stormtypes.toint(duration, noneok=True)
@@ -1703,6 +1720,8 @@ class LibUsers(s_stormtypes.Lib):
          'desc': 'Controls changing a user\'s email address.'},
         {'perm': ('auth', 'user', 'set', 'locked'), 'gate': 'cortex',
          'desc': 'Controls locking/unlocking a user account.'},
+        {'perm': ('auth', 'user', 'set', 'archived'), 'gate': 'cortex',
+         'desc': 'Controls archiving/unarchiving a user account.'},
         {'perm': ('auth', 'user', 'set', 'passwd'), 'gate': 'cortex',
          'desc': 'Controls changing a user password.'},
         {'perm': ('auth', 'user', 'set', 'rules'), 'gate': 'cortex',

synapse/lib/stormlib/cell.py

@@ -2,11 +2,16 @@ import asyncio
 import logging
 
 import synapse.exc as s_exc
-import synapse.lib.const as s_const
+import synapse.lib.autodoc as s_autodoc
 import synapse.lib.stormtypes as s_stormtypes
 
 logger = logging.getLogger(__name__)
 
+def prepHotfixDesc(txt):
+    lines = txt.split('\n')
+    lines = s_autodoc.scrubLines(lines)
+    lines = s_autodoc.ljuster(lines)
+    return lines
 
 storm_missing_autoadds = '''
 $absoluteOrder = $lib.view.list(deporder=$lib.true)
@@ -64,6 +69,17 @@ for $view in $views {
 }
 '''
 
+storm_migrate_riskhasvuln = '''
+for $view in $lib.view.list(deporder=$lib.true) {
+    view.exec $view.iden {
+        $layer = $lib.layer.get()
+        for ($buid, $sode) in $layer.getStorNodesByForm(risk:hasvuln) {
+            yield $buid
+            $lib.model.migration.s.riskHasVulnToVulnerable($node)
+        }
+    }
+}
+'''
 
 hotfixes = (
     ((1, 0, 0), {
@@ -78,6 +94,20 @@ hotfixes = (
         'desc': 'Populate it:sec:cpe:v2_2 properties from existing CPE where the property is not set.',
         'query': storm_missing_cpe22,
     }),
+    ((4, 0, 0), {
+        'desc': '''
+            Create risk:vulnerable nodes from existing risk:hasvuln nodes.
+
+            This hotfix should only be applied after all logic that would create
+            risk:hasvuln nodes has been updated. The hotfix uses the
+            $lib.model.migration.s.riskHasVulnToVulnerable() function,
+            which can be used directly for testing.
+
+            Tags, tag properties, edges, and node data will all be copied
+            to the risk:vulnerable nodes.
+        ''',
+        'query': storm_migrate_riskhasvuln,
+    }),
 )
 runtime_fixes_key = 'cortex:runtime:stormfixes'
 
@@ -174,7 +204,9 @@ class CellLib(s_stormtypes.Lib):
             assert desc is not None
             assert vars is not None
 
-            await self.runt.printf(f'Applying hotfix {vers} for [{desc}]')
+            title = prepHotfixDesc(desc)[0]
+            await self.runt.printf(f'Applying hotfix {vers} for [{title}]')
+
             try:
                 query = await self.runt.getStormQuery(text)
                 async with self.runt.getSubRuntime(query, opts={'vars': vars}) as runt:
@@ -206,8 +238,14 @@ class CellLib(s_stormtypes.Lib):
                 continue
 
             dowork = True
-            desc = info.get('desc')
-            await self.runt.printf(f'Would apply fix {vers} for [{desc}]')
+
+            desclines = prepHotfixDesc(info.get('desc'))
+            await self.runt.printf(f'Would apply fix {vers} for [{desclines[0]}]')
+            if len(desclines) > 1:
+                for line in desclines[1:]:
+                    await self.runt.printf(f'    {line}' if line else '')
+            else:
+                await self.runt.printf('')
 
         return dowork