@jacebenson/jsn 3.1.3 → 3.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacebenson/jsn",
-  "version": "3.1.3",
+  "version": "3.1.5",
   "description": "A command-line interface for ServiceNow that follows the Unix philosophy: simple, composable, and scriptable.",
   "type": "module",
   "bin": {

package/src/auth.js

@@ -7,8 +7,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import readline from 'node:readline';
 import { execSync } from 'node:child_process';
+import { password as passwordPrompt } from '@inquirer/prompts';
 import { globalConfigDir, normalizeInstanceURL } from './config.js';
 import { errAuth } from './errors.js';
 
@@ -248,52 +248,7 @@ function deleteCredentials(instance, username) {
 }
 
 function askHidden(promptText) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-
-    if (!stdin.isTTY) {
-    rl.question(promptText, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-    return;
-  }
-
-    stdout.write(promptText);
-
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding('utf-8');
-
-    let input = '';
-    const onData = (key) => {
-      if (key === '\r' || key === '\n') {
-        stdin.removeListener('data', onData);
-        stdin.setRawMode(false);
-        stdin.pause();
-        stdout.write('\n');
-        rl.close();
-        resolve(input);
-      } else if (key === '\u0003') {
-        process.exit();
-      } else if (key === '\u007f') {
-        if (input.length > 0) {
-          input = input.slice(0, -1);
-          stdout.write('\b \b');
-        }
-      } else {
-        input += key;
-        stdout.write('*');
-      }
-    };
-    stdin.on('data', onData);
-  });
+  return passwordPrompt({ message: promptText });
 }
 
 export class AuthManager {

package/src/cli.js

@@ -35,12 +35,13 @@ import {
   spPagesCmd, spWidgetsCmd, uiPagesCmd, appMenuCmd,
   aclsCmd, rolesCmd, propertiesCmd,
   relationshipsCmd, appmodulesCmd, listcontrolsCmd, viewsCmd,
-  privilegesCmd, securitytypesCmd, uxscriptsCmd, aliasesCmd,
+  privilegesCmd, uxscriptsCmd, aliasesCmd,
   catalogscriptsCmd, cataloguipoliciesCmd,
+  uipoliciesCmd,
   scriptactionsCmd, scheduledjobsCmd, asyncrulesCmd, triggersCmd,
-  workflowsCmd, decisiontablesCmd, assignmentsCmd,
+  decisiontablesCmd, assignmentsCmd,
   emailCmd,
-  restmessageCmd, restmethodsCmd, soapmessagesCmd, soapfunctionsCmd,
+  restmessageCmd, soapmessagesCmd,
   uimacrosCmd, uxlistsCmd, uxapplicabilityCmd,
 } from './commands/dev/_simple.js';
 import { flowsCmd } from './commands/dev/flows.js';
@@ -222,7 +223,6 @@ export function buildCLI() {
     .command(triggersCmd(wrap))
     // AUTOMATION — In Memory
     .command(rulesCmd(wrap))
-    .command(workflowsCmd(wrap))
     .command(decisiontablesCmd(wrap))
     .command(assignmentsCmd(wrap))
     // AUTOMATION — Inbound
@@ -230,15 +230,12 @@ export function buildCLI() {
     .command(emailCmd(wrap))
     // AUTOMATION — Outbound
     .command(restmessageCmd(wrap))
-    .command(restmethodsCmd(wrap))
     .command(soapmessagesCmd(wrap))
-    .command(soapfunctionsCmd(wrap))
     // ACCESS
     .command(aclsCmd(wrap))
     .command(b4rulesCmd(wrap))
     .command(rolesCmd(wrap))
     .command(privilegesCmd(wrap))
-    .command(securitytypesCmd(wrap))
     .command(aliasesCmd(wrap))
     .command(groupsCmd(wrap))
     .command(groupMembersCmd(wrap))
@@ -252,6 +249,7 @@ export function buildCLI() {
     .command(uiActionsCmd(wrap))
     .command(viewsCmd(wrap))
     .command(catalogscriptsCmd(wrap))
+    .command(uipoliciesCmd(wrap))
     .command(cataloguipoliciesCmd(wrap))
     // USER EXPERIENCE — Core UI
     .command(uiPagesCmd(wrap))

package/src/commands/catalog.js

@@ -14,9 +14,34 @@ export function catalogCmd(wrap) {
           builder: (y) => y
             .option('name', { alias: 'n', type: 'string', demandOption: true })
             .option('short-description', { alias: 'd', type: 'string' })
-            .option('category', { alias: 'c', type: 'string' }),
+            .option('category', { alias: 'c', type: 'string' })
+            .option('variable', { alias: 'v', type: 'array', describe: 'Variable: "name:type:label"' })
+            .option('variables', { type: 'string', describe: 'JSON for submit_produce: {\"key\":\"value\"}' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
+
+            // submit_produce path
+            if (argv.variables) {
+              let varsObj;
+              try { varsObj = JSON.parse(argv.variables); } catch { throw new Error('--variables must be valid JSON'); }
+              let itemSysID = argv.name;
+              if (!/^[a-f0-9]{32}$/i.test(itemSysID)) {
+                const sp = new URLSearchParams();
+                sp.set('sysparm_query', `name=${itemSysID}`);
+                sp.set('sysparm_limit', '1');
+                sp.set('sysparm_fields', 'sys_id');
+                const items = await app.sdk.list('sc_cat_item', sp);
+                if (items.length === 0) throw new Error(`Not found: ${itemSysID}`);
+                itemSysID = items[0].sys_id?.value || items[0].sys_id;
+              }
+              const endpoint = `${app.sdk.baseURL}/api/sn_sc/servicecatalog/items/${itemSysID}/submit_produce`;
+              const result = await app.sdk.request(endpoint, { method: 'POST', body: JSON.stringify({ variables: varsObj }) });
+              const reqID = result?.result?.sys_id || result?.result?.number || '';
+              app.ok({ requested_item: reqID, item_id: itemSysID, variables: varsObj },
+                { summary: `Request: ${result?.result?.number || reqID}` });
+              return;
+            }
+
             let categoryID = '';
             if (argv.category) {
               const cp = new URLSearchParams();
@@ -34,7 +59,31 @@ export function catalogCmd(wrap) {
               active: true,
               type: 'item',
             });
-            app.ok(item, { summary: `Created: ${argv.name}` });
+            const itemID = item.sys_id?.value || item.sys_id;
+
+            // Create variables if --variable flag(s) provided
+            let varCount = 0;
+            if (argv.variable) {
+              for (const v of argv.variable) {
+                const parts = String(v).split(':');
+                if (parts.length >= 2) {
+                  const typeName = parts.length >= 2 ? parts[parts.length - 1] : '';
+                  const label = parts.length >= 3 ? parts[parts.length - 1] : parts[0];
+                  const sysName = parts[0].replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase();
+                  try {
+                    const typeMap = { string: '6', multilinetext: '2', select: '3', date: '4', datetime: '5', reference: '8', checkbox: '12', email: '11' };
+                    await app.sdk.create('item_option_new', {
+                      name: sysName, question_text: label, type: typeMap[typeName] || '6',
+                      order: (varCount + 1) * 100, cat_item: itemID, mandatory: true, active: true,
+                    });
+                    varCount++;
+                  } catch { /* non-fatal */ }
+                }
+              }
+            }
+
+            app.ok({ sys_id: itemID, name: argv.name, variables_created: varCount },
+              { summary: `Created: ${argv.name}${varCount ? ` (${varCount} variable(s))` : ''}` });
           }),
         })
         .command({
@@ -43,10 +92,11 @@ export function catalogCmd(wrap) {
           describe: 'List catalog items',
           builder: (y) => y
             .option('limit', { alias: 'l', type: 'number', default: 50 })
-            .option('category', { type: 'string' }),
+            .option('category', { type: 'string' })
+            .option('query', { type: 'string', describe: 'Encoded query (e.g. active=true)' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
-            const query = argv.category ? `category.titleLIKE${argv.category}` : '';
+            const query = argv.query || (argv.category ? `category.titleLIKE${argv.category}` : '');
 
             const picked = await interactiveList({
               app,
@@ -69,20 +119,27 @@ export function catalogCmd(wrap) {
               return;
             }
 
-            // Fallback — non-TTY
+            // Fallback — non-TTY / --json / --styled
             const p = new URLSearchParams();
             p.set('sysparm_query', query ? `${query}^ORDERBYname` : 'ORDERBYname');
             p.set('sysparm_limit', String(argv.limit));
             p.set('sysparm_display_value', 'all');
             p.set('sysparm_fields', 'name,short_description,category,active');
             const records = await app.sdk.list('sc_cat_item', p);
+            // Map reference fields to strings for styled/table renderer
+            const safe = records.map(r => ({
+              name: getStringField(r, 'name'),
+              short_description: getStringField(r, 'short_description'),
+              category: getStringField(r, 'category'),
+              active: getStringField(r, 'active'),
+            }));
             app.ok({
               table: 'sc_cat_item',
-              count: records.length,
+              count: safe.length,
               columns: ['name', 'short_description', 'category', 'active'],
-              records,
+              records: safe,
               context: { instance_url: app.getEffectiveInstance() },
-            }, { summary: `${records.length} catalog item(s)` });
+            }, { summary: `${safe.length} catalog item(s)` });
           }),
         })
         .command({
@@ -101,7 +158,6 @@ export function catalogCmd(wrap) {
               if (results.length === 0) throw new Error(`Not found: ${id}`);
               id = results[0].sys_id?.value || results[0].sys_id;
             }
-            const item = await app.sdk.get('sc_cat_item', id);
             await showItem(app, id);
           }),
         });
@@ -120,7 +176,6 @@ export function catalogCmd(wrap) {
 async function showItem(app, sysID) {
   const item = await app.sdk.get('sc_cat_item', sysID);
 
-  // Fetch variables
   const vp = new URLSearchParams();
   vp.set('sysparm_query', `cat_item=${sysID}^active=true`);
   vp.set('sysparm_limit', '100');
@@ -145,68 +200,40 @@ async function showItem(app, sysID) {
       standalone.push(entry);
     }
   }
-
   const totalVars = standalone.length + Array.from(setVars.values()).reduce((a, s) => a + s.variables.length, 0);
 
-  const lines = [];
-  lines.push(getStringField(item, 'name'));
-  if (getStringField(item, 'short_description')) lines.push(`  ${getStringField(item, 'short_description')}`);
-  lines.push(`  Category: ${getStringField(item, 'category') || '(none)'}`);
-  lines.push(`  Active: ${getStringField(item, 'active') || 'false'}`);
-  lines.push(`  URL: ${app.getEffectiveInstance()}/sc_cat_item.do?sys_id=${sysID}`);
-
-  // Flow / Workflow / Execution Plan
-  const flowName = getStringField(item, 'flow_designer_flow');
-  const flowID = item.flow_designer_flow?.value || '';
-  const wfName = getStringField(item, 'workflow');
-  const wfID = item.workflow?.value || '';
-  const planName = getStringField(item, 'delivery_plan') || getStringField(item, 'execution_plan');
-
-  if (flowID) {
-    if (flowName === flowID) {
-      try {
-        const flowRec = await app.sdk.get('sys_hub_flow', flowID);
-        lines.push(`  Flow: ${getStringField(flowRec, 'name') || flowID}`);
-      } catch {
-        lines.push(`  Flow: ${flowName}`);
-      }
-    } else {
-      lines.push(`  Flow: ${flowName}`);
-    }
-    lines.push(`    → jsn flows show ${flowID}`);
-  } else if (wfName) {
-    lines.push(`  Workflow: ${wfName}`);
-    if (wfID) lines.push(`    → jsn workflows show ${wfID}`);
-  } else if (planName) {
-    const planID = item.delivery_plan?.value || item.execution_plan?.value || '';
-    if (planName === planID && planID) {
-      try {
-        const planRec = await app.sdk.get('delivery_plan', planID);
-        const realName = getStringField(planRec, 'name') || getStringField(planRec, 'short_description') || planID;
-        lines.push(`  Execution Plan: ${realName}`);
-        lines.push(`    → jsn records get --table delivery_plan --sys-id ${planID}`);
-      } catch {
-        lines.push(`  Execution Plan: ${planName}`);
-      }
-    } else {
-      lines.push(`  Execution Plan: ${planName}`);
-    }
-  }
-
-  if (totalVars > 0) {
-    lines.push(`  Variables (${totalVars}):`);
-    for (const v of standalone) {
-      const flags = String(v.mandatory) === 'true' ? ' [required]' : '';
-      lines.push(`    ${v.question_text || v.name}  ${v.type || ''}${flags}`);
-    }
-    for (const [_, sd] of setVars) {
-      lines.push(`    [${sd.name}]`);
-      for (const v of sd.variables) {
-        const flags = String(v.mandatory) === 'true' ? ' [required]' : '';
-        lines.push(`      ${v.question_text || v.name}  ${v.type || ''}${flags}`);
-      }
-    }
+  // Resolve flow name
+  let flowName = '', flowCmd = '';
+  const flowVal = item.flow_designer_flow;
+  if (flowVal?.value) {
+    const fn = getStringField(item, 'flow_designer_flow');
+    if (fn === flowVal.value) {
+      try { const fr = await app.sdk.get('sys_hub_flow', flowVal.value); flowName = getStringField(fr, 'name') || ''; } catch { flowName = fn; }
+    } else { flowName = fn; }
+    flowCmd = `jsn flows show ${flowVal.value}`;
   }
+  const wfName = getStringField(item, 'workflow') || '';
+  const wfID = item.workflow?.value || '';
+  const planName = getStringField(item, 'delivery_plan') || getStringField(item, 'execution_plan') || '';
+  const planID = item.delivery_plan?.value || item.execution_plan?.value || '';
 
-  console.log(lines.join('\n'));
+  app.ok({
+    name: getStringField(item, 'name'),
+    short_description: getStringField(item, 'short_description'),
+    category: getStringField(item, 'category'),
+    active: getStringField(item, 'active'),
+    url: `${app.getEffectiveInstance()}/sc_cat_item.do?sys_id=${sysID}`,
+    flow: flowName || undefined,
+    flow_cmd: flowCmd || undefined,
+    workflow: wfName || undefined,
+    workflow_cmd: (wfName && wfID) ? `jsn workflows show ${wfID}` : undefined,
+    execution_plan: planName || undefined,
+    variables: totalVars > 0 ? {
+      count: totalVars,
+      standalone: standalone.map(v => ({ label: v.question_text || v.name, type: v.type, mandatory: String(v.mandatory) === 'true' })),
+      sets: Array.from(setVars.values()).map(s => ({ name: s.name, variables: s.variables.map(v => ({ label: v.question_text || v.name, type: v.type, mandatory: String(v.mandatory) === 'true' })) })),
+    } : undefined,
+  }, {
+    summary: `${getStringField(item, 'name')} — ${totalVars} variable(s)`,
+  });
 }

package/src/commands/dev/_generic.js

@@ -81,6 +81,7 @@ export function buildDevCmd(name, table, aliases, defaultColumns, wrap, opts = {
   const readOnly = opts.readOnly || false;
   const scopeValidation = opts.scopeValidation || false;
   const extraQuery = opts.extraQuery || '';
+  const formatLabel = opts.formatLabel || null;
   const showSummary = opts.showSummary || ((record, id) => `${singular.charAt(0).toUpperCase() + singular.slice(1)}: ${getStringField(record, 'name') || id}`);
   const showBreadcrumbs = opts.showBreadcrumbs || ((record, id) => {
     const crumbs = [

package/src/commands/dev/_simple.js

@@ -73,10 +73,10 @@ export const tablesCmd = (wrap) => buildDevCmd('tables', 'sys_db_object', ['tabl
   },
 });
 
-export const columnsCmd = (wrap) => buildDevCmd('columns', 'sys_dictionary', ['column', 'col'], ['element', 'column_label', 'internal_type', 'mandatory', 'max_length', 'active'], wrap, { singular: 'column', scopeValidation: true });
+export { columnsCmd } from './columns.js';
 
 // Read-only commands (Go only has list/show)
-export const importCmd = (wrap) => buildDevCmd('import', 'sys_import_set', ['imports', 'imp'], ['sys_import_set', 'sys_import_row', 'sys_target_table', 'sys_target_sys_id'], wrap, { singular: 'import set', readOnly: true });
+export { importCmd } from './import.js';
 export const spPagesCmd = (wrap) => buildDevCmd('sppages', 'sp_page', ['sp-pages', 'pages'], ['id', 'title', 'sys_scope'], wrap, { singular: 'Service Portal page', readOnly: true });
 export const spWidgetsCmd = (wrap) => buildDevCmd('spwidgets', 'sp_widget', ['sp-widget', 'widgets'], ['id', 'name', 'sys_scope'], wrap, { singular: 'Service Portal widget', readOnly: true });
 export const uiPagesCmd = (wrap) => buildDevCmd('uipages', 'sys_ui_page', ['ui-page', 'pages'], ['name', 'sys_scope'], wrap, { singular: 'UI page', scopeValidation: true });
@@ -92,31 +92,28 @@ export const relationshipsCmd = (wrap) => buildDevCmd('relationships', 'sys_rela
 export const appmodulesCmd = (wrap) => buildDevCmd('appmodules', 'sys_app_module', ['appmodule', 'am'], ['name', 'active', 'sys_scope'], wrap, { singular: 'application module', scopeValidation: true });
 export const listcontrolsCmd = (wrap) => buildDevCmd('listcontrols', 'sys_ui_list_control', ['listcontrol', 'lc'], ['name', 'active', 'sys_scope'], wrap, { singular: 'list control', scopeValidation: true });
 export const viewsCmd = (wrap) => buildDevCmd('views', 'sys_ui_view', ['view', 'vw'], ['name', 'title', 'sys_scope'], wrap, { singular: 'view', scopeValidation: true });
-export const privilegesCmd = (wrap) => buildDevCmd('privileges', 'sys_scope_privilege', ['privilege', 'priv'], ['name', 'status', 'sys_scope'], wrap, { singular: 'privilege', scopeValidation: true });
-export const securitytypesCmd = (wrap) => buildDevCmd('securitytypes', 'sys_security_type', ['securitytype', 'st'], ['name', 'active', 'sys_scope'], wrap, { singular: 'security type', scopeValidation: true });
+export const privilegesCmd = (wrap) => buildDevCmd('privileges', 'sys_scope_privilege', ['privilege', 'priv'], ['source_scope', 'target_scope', 'target_name', 'operation', 'status'], wrap, { singular: 'privilege', scopeValidation: true });
 export const uxscriptsCmd = (wrap) => buildDevCmd('uxscripts', 'sys_ux_lib_source_script', ['uxscript', 'ux'], ['name', 'active', 'sys_scope'], wrap, { singular: 'UX script', scopeValidation: true });
-export const aliasesCmd = (wrap) => buildDevCmd('aliases', 'sys_alias', ['alias', 'als'], ['name', 'table', 'sys_scope'], wrap, { singular: 'alias', scopeValidation: true });
+export { aliasesCmd } from './aliases.js';
 export const catalogscriptsCmd = (wrap) => buildDevCmd('catalogscripts', 'catalog_script_client', ['catalogscript', 'cs'], ['name', 'table', 'active', 'sys_scope'], wrap, { singular: 'catalog script', scopeValidation: true });
 
 // ── Automation: Async ──
 export const scriptactionsCmd = (wrap) => buildDevCmd('scriptactions', 'sysevent_script_action', ['scriptaction'], ['name', 'active', 'sys_scope'], wrap, { singular: 'script action', scopeValidation: true });
 export const scheduledjobsCmd = (wrap) => buildDevCmd('scheduledjobs', 'sysauto_script', ['scheduledjob'], ['name', 'active', 'run_type', 'sys_scope'], wrap, { singular: 'scheduled job', scopeValidation: true });
-export const asyncrulesCmd = (wrap) => buildDevCmd('asyncrules', 'sys_script', ['asyncrule'], ['name', 'collection', 'active', 'order', 'sys_scope'], wrap, { singular: 'async business rule', scopeValidation: true, extraQuery: 'order>=1000' });
+export const asyncrulesCmd = (wrap) => buildDevCmd('asyncrules', 'sys_script', ['asyncrule'], ['name', 'collection', 'active', 'order', 'sys_scope'], wrap, { singular: 'async business rule', scopeValidation: true, extraQuery: 'when=async' });
 export const triggersCmd = (wrap) => buildDevCmd('triggers', 'sysevent_register', ['trigger'], ['name', 'event_name', 'active', 'sys_scope'], wrap, { singular: 'event trigger', scopeValidation: true });
 
 // ── Automation: In Memory ──
-export const workflowsCmd = (wrap) => buildDevCmd('workflows', 'wf_workflow', ['workflow'], ['name', 'table', 'active', 'sys_scope'], wrap, { singular: 'workflow', scopeValidation: true, readOnly: true });
-export const decisiontablesCmd = (wrap) => buildDevCmd('decisiontables', 'sys_decision', ['decisiontable'], ['name', 'active', 'sys_scope'], wrap, { singular: 'decision table', scopeValidation: true, readOnly: true });
+export const decisiontablesCmd = (wrap) => buildDevCmd('decisiontables', 'sys_ws_definition', ['decisiontable'], ['name', 'active', 'sys_scope'], wrap, { singular: 'decision table', scopeValidation: true, readOnly: true });
 export const assignmentsCmd = (wrap) => buildDevCmd('assignments', 'sysrule_assignment', ['assignment'], ['name', 'active', 'sys_scope'], wrap, { singular: 'assignment rule', scopeValidation: true, readOnly: true });
 
 // ── Automation: Inbound ──
-export const emailCmd = (wrap) => buildDevCmd('email', 'sysevent_email_action', ['emails'], ['name', 'active', 'event_name', 'sys_scope'], wrap, { singular: 'inbound email action', scopeValidation: true });
+export const emailCmd = (wrap) => buildDevCmd('email', 'sysevent_in_email_action', ['emails'], ['name', 'active', 'type', 'sys_scope'], wrap, { singular: 'inbound email action', scopeValidation: true });
 
 // ── Automation: Outbound ──
-export const restmessageCmd = (wrap) => buildDevCmd('restmessage', 'sys_rest_message', ['rm', 'restmsg'], ['name', 'endpoint', 'active', 'sys_scope'], wrap, { singular: 'REST message', scopeValidation: true });
+export { restmessageCmd } from './restmessage.js';
 export const restmethodsCmd = (wrap) => buildDevCmd('restmethods', 'sys_rest_message_fn', ['restmethod'], ['name', 'http_method', 'active', 'sys_scope'], wrap, { singular: 'REST method', scopeValidation: true });
-export const soapmessagesCmd = (wrap) => buildDevCmd('soapmessages', 'sys_soap_message', ['soapmsg'], ['name', 'active', 'sys_scope'], wrap, { singular: 'SOAP message', scopeValidation: true });
-export const soapfunctionsCmd = (wrap) => buildDevCmd('soapfunctions', 'sys_soap_message_function', ['soapfunc'], ['name', 'active', 'sys_scope'], wrap, { singular: 'SOAP function', scopeValidation: true });
+export { soapmessagesCmd } from './soapmessages.js';
 
 // ── UX: Core UI ──
 export const uimacrosCmd = (wrap) => buildDevCmd('uimacros', 'sys_ui_macro', ['uimacro'], ['name', 'active', 'sys_scope'], wrap, { singular: 'UI macro', scopeValidation: true });
@@ -124,4 +121,5 @@ export const uimacrosCmd = (wrap) => buildDevCmd('uimacros', 'sys_ui_macro', ['u
 // ── UX: Workspaces ──
 export const uxlistsCmd = (wrap) => buildDevCmd('uxlists', 'sys_ux_list', ['uxlist'], ['name', 'active', 'sys_scope'], wrap, { singular: 'workspace list', scopeValidation: true, readOnly: true });
 export const uxapplicabilityCmd = (wrap) => buildDevCmd('uxapplicability', 'sys_ux_applicability_m2m', ['uxapp'], ['name', 'active', 'sys_scope'], wrap, { singular: 'workspace applicability', scopeValidation: true, readOnly: true });
-export const cataloguipoliciesCmd = (wrap) => buildDevCmd('cataloguipolicies', 'catalog_ui_policy', ['cataloguipolicy', 'cup'], ['short_description', 'table', 'active', 'sys_scope'], wrap, { singular: 'catalog UI policy', scopeValidation: true });
+export { uipoliciesCmd } from './uipolicies.js';
+export const cataloguipoliciesCmd = (wrap) => buildDevCmd('cataloguipolicies', 'catalog_ui_policy', ['cataloguipolicy', 'cup'], ['short_description', 'catalog_item', 'variable_set', 'active', 'sys_scope'], wrap, { singular: 'catalog UI policy', scopeValidation: true });

package/src/commands/dev/aliases.js

@@ -0,0 +1,30 @@
+import { buildDevCmd } from './_generic.js';
+import { getStringField } from '../../helpers.js';
+
+export const aliasesCmd = (wrap) => buildDevCmd('aliases', 'sys_alias', ['alias', 'als'],
+  ['name', 'table', 'sys_scope'], wrap, {
+    singular: 'alias',
+    scopeValidation: true,
+    onShow: async (record, app) => {
+      const sysID = getStringField(record, 'sys_id') || '';
+      if (!sysID) return;
+
+      const mp = new URLSearchParams();
+      mp.set('sysparm_query', `connection_alias=${sysID}^ORDERBYname`);
+      mp.set('sysparm_limit', '100');
+      mp.set('sysparm_display_value', 'all');
+      mp.set('sysparm_fields', 'name,active,credential,sys_id');
+      const conns = await app.sdk.list('sys_connection', mp);
+
+      if (conns.length > 0) {
+        console.log(`  Connections (${conns.length}):`);
+        for (const c of conns) {
+          const name = getStringField(c, 'name') || '';
+          const cred = getStringField(c, 'credential') || '';
+          const cid = getStringField(c, 'sys_id') || '';
+          console.log(`    ${name}${cred ? ` → ${cred}` : ''}`);
+          console.log(`      → jsn records get --table sys_connection --sys-id ${cid}`);
+        }
+      }
+    },
+  });

package/src/commands/dev/b4rules.js

@@ -2,4 +2,4 @@ import { buildDevCmd } from './_generic.js';
 
 // Before-query business rules — applies filters to GlideRecord queries before they execute.
 // These are sys_script records with order < 100.
-export const b4rulesCmd = (wrap) => buildDevCmd('b4rules', 'sys_script', ['b4rule'], ['name', 'collection', 'active', 'order', 'sys_scope'], wrap, { singular: 'before-query business rule', scopeValidation: true, extraQuery: 'order<100' });
+export const b4rulesCmd = (wrap) => buildDevCmd('b4rules', 'sys_script', ['b4rule'], ['name', 'collection', 'active', 'order', 'sys_scope'], wrap, { singular: 'before-query business rule', scopeValidation: true, extraQuery: 'when=before' });

package/src/commands/dev/columns.js

@@ -0,0 +1,27 @@
+import { buildDevCmd } from './_generic.js';
+
+export const columnsCmd = (wrap) => {
+  const base = buildDevCmd('columns', 'sys_dictionary', ['column', 'col'],
+    ['element', 'column_label', 'internal_type', 'mandatory', 'max_length', 'active'],
+    wrap, { singular: 'column', scopeValidation: true });
+
+  // Add --table filter
+  const origBuilder = base.builder;
+  base.builder = (yargs) => {
+    const built = origBuilder(yargs);
+    // Patch the 'list' subcommand builder to add --table
+    const listCmd = built._commands?.find(c => c.name === 'list' || c._aliases?.includes('ls'));
+    if (listCmd) {
+      const origListBuilder = listCmd.builder;
+      listCmd.builder = (y) => (origListBuilder ? origListBuilder(y).option('table', { type: 'string', describe: 'Filter by table (e.g. incident)' }) : y.option('table', { type: 'string' }));
+      const origHandler = listCmd.handler;
+      listCmd.handler = async (argv) => {
+        if (argv.table) argv.query = argv.query ? `${argv.query}^name=${argv.table}` : `name=${argv.table}`;
+        return origHandler(argv);
+      };
+    }
+    return built;
+  };
+
+  return base;
+};

package/src/commands/dev/import.js

@@ -0,0 +1,27 @@
+import { buildDevCmd } from './_generic.js';
+import { getStringField } from '../../helpers.js';
+
+export const importCmd = (wrap) => buildDevCmd('import', 'sys_import_set', ['imports', 'imp'],
+  ['name', 'sys_target_table', 'state', 'sys_created_on'], wrap, {
+    singular: 'import set',
+    readOnly: true,
+    formatLabel: (r) => {
+      const name = getStringField(r, 'name') || '';
+      const table = getStringField(r, 'sys_target_table') || '';
+      return table ? `${name} [${table}]` : name;
+    },
+    onShow: async (record, app) => {
+      const sysID = getStringField(record, 'sys_id') || '';
+      if (!sysID) return;
+      try {
+        const rp = new URLSearchParams();
+        rp.set('sysparm_query', `sys_import_set=${sysID}`);
+        rp.set('sysparm_limit', '0'); rp.set('sysparm_fields', 'sys_id');
+        const rows = await app.sdk.list('sys_import_set_row', rp);
+        console.log(`  Import rows: ${rows.length}`);
+        console.log(`    → jsn records list --table sys_import_set_row --query "sys_import_set=${sysID}" --limit 200`);
+      } catch (err) {
+        console.log(`  Import rows: (unavailable)`);
+      }
+    },
+  });

package/src/commands/dev/lists.js

@@ -1,99 +1,68 @@
-import chalk from 'chalk';
-import { getStringField } from '../../helpers.js';
-
-// ─── Helpers ───
-
-function getDisplayValue(record, key) {
-  if (!record || typeof record !== 'object') return '';
-  const val = record[key];
-  if (val == null) return '';
-  if (typeof val === 'string') return val;
-  if (typeof val === 'object') {
-    if (val.display_value != null && val.display_value !== '') return String(val.display_value);
-    if (val.value != null) return String(val.value);
-  }
-  return String(val);
-}
-
-function getIntValue(record, key) {
-  if (!record || typeof record !== 'object') return 0;
-  const val = record[key];
-  if (val == null) return 0;
-  if (typeof val === 'number') return Math.floor(val);
-  if (typeof val === 'string') {
-    const n = parseInt(val, 10);
-    return isNaN(n) ? 0 : n;
-  }
-  if (typeof val === 'object' && val.value != null) {
-    const n = parseInt(val.value, 10);
-    return isNaN(n) ? 0 : n;
-  }
-  return 0;
-}
-
-// ─── Commands ───
+import { getStringField, interactiveList } from '../../helpers.js';
 
 export function listsCmd(wrap) {
   return {
     command: 'lists [subcommand]',
     aliases: ['list-layout', 'l'],
-    describe: 'Manage UI List layouts',
+    describe: 'List views for a table',
     builder: (yargs) => {
       return yargs
         .command({
-          command: 'list <table>',
+          command: 'list [table]',
           aliases: ['ls'],
-          describe: 'List list views for a table',
+          describe: 'List views for a table (or pick from all tables)',
           builder: (y) => y
-            .positional('table', {
-              describe: 'Table name (e.g. incident, change_request)',
-              type: 'string',
-            })
-            .option('limit', { alias: 'l', type: 'number', default: 50, describe: 'Max records' }),
+            .positional('table', { type: 'string', describe: 'Table name (e.g. incident)' })
+            .option('limit', { alias: 'l', type: 'number', default: 50 }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
-            const table = argv.table;
-            const limit = argv.limit || 50;
-
-            const params = new URLSearchParams();
-            params.set('sysparm_limit', String(limit));
-            params.set('sysparm_fields', 'view');
-            params.set('sysparm_group_by', 'view');
-            params.set('sysparm_display_value', 'all');
-            const sysparmQuery = table ? `name=${table}^ORDERBYview` : 'ORDERBYview';
-            params.set('sysparm_query', sysparmQuery);
-
-            const records = await app.sdk.list('sys_ui_list', params);
-
-            const viewMap = new Map();
-            for (const record of records) {
-              const view = getDisplayValue(record, 'view');
-              if (view && !viewMap.has(view)) {
-                viewMap.set(view, true);
-              }
+            let table = argv.table;
+            let viewSysID = null;
+
+            // If no table, pick one interactively
+            if (!table) {
+              const tpicked = await interactiveList({
+                app, table: 'sys_ui_list', singular: 'table',
+                columns: ['name'],
+                limit: argv.limit,
+                labelField: 'name',
+                groupBy: 'name',
+              });
+              if (!tpicked) return;
+              table = getStringField(tpicked, 'name');
             }
 
-            const views = Array.from(viewMap.keys()).sort();
-            const defaultViews = views.filter(v => v === 'Default view');
-            const workspaceViews = views.filter(v => v.toLowerCase().includes('workspace'));
-            const otherViews = views.filter(v => !defaultViews.includes(v) && !workspaceViews.includes(v));
+            // Show list views for table
+            const picked = await interactiveList({
+              app, table: 'sys_ui_list', singular: 'list',
+              columns: ['name', 'view'],
+              limit: argv.limit,
+              query: table ? `name=${table}` : '',
+              labelField: 'view',
+              formatLabel: (r) => `${getStringField(r, 'view')}`,
+            });
 
-            const recordsOut = views.map(v => ({ view: v, table }));
+            if (picked) {
+              const sysID = getStringField(picked, 'sys_id') || '';
+              viewSysID = getStringField(picked, 'view') || '';
+              await showList(app, table, viewSysID, sysID);
+              return;
+            }
 
+            // Fallback non-TTY
+            const p = new URLSearchParams();
+            p.set('sysparm_limit', String(argv.limit));
+            p.set('sysparm_display_value', 'all');
+            p.set('sysparm_fields', 'name,view');
+            p.set('sysparm_query', table ? `name=${table}^ORDERBYview` : 'ORDERBYview');
+            const records = await app.sdk.list('sys_ui_list', p);
             app.ok({
-              table,
-              count: views.length,
-              default: defaultViews,
-              workspaces: workspaceViews,
-              other: otherViews,
-              records: recordsOut,
-              instance_url: app.getEffectiveInstance(),
-            }, {
-              summary: `${views.length} list views for ${table}`,
-              breadcrumbs: [
-                { action: 'show', cmd: `jsn lists show ${table} --view "Default view"`, description: 'Show Default view columns' },
-              ],
-            });
+              table: 'sys_ui_list',
+              count: records.length,
+              columns: ['name', 'view'],
+              records: records.map(r => ({ name: getStringField(r, 'name'), view: getStringField(r, 'view') })),
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} list view(s)${table ? ` for ${table}` : ''}` });
           }),
         })
         .command({
@@ -101,147 +70,61 @@ export function listsCmd(wrap) {
           aliases: ['get'],
           describe: 'Show list layout',
           builder: (y) => y
-            .option('view', { type: 'string', default: 'Default view', describe: 'View name' }),
+            .option('view', { type: 'string', default: 'Default view' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
             const table = argv.table;
-            const viewName = argv.view;
 
-            // Look up view sys_id
+            // Resolve view sys_id
             let viewSysID = '';
-            const viewParams = new URLSearchParams();
-            viewParams.set('sysparm_limit', '1');
-            viewParams.set('sysparm_fields', 'sys_id');
-            viewParams.set('sysparm_query', `name=${viewName}`);
-            try {
-              const viewRecords = await app.sdk.list('sys_ui_view', viewParams);
-              if (viewRecords.length > 0) {
-                viewSysID = getStringField(viewRecords[0], 'sys_id');
-              }
-            } catch {
-              // ignore
-            }
-
-            if (!viewSysID) {
-              viewParams.set('sysparm_query', `title=${viewName}`);
-              try {
-                const viewRecords = await app.sdk.list('sys_ui_view', viewParams);
-                if (viewRecords.length > 0) {
-                  viewSysID = getStringField(viewRecords[0], 'sys_id');
-                }
-              } catch {
-                // ignore
-              }
-            }
-
-            if (!viewSysID) {
-              viewSysID = viewName;
-            }
-
-            // Fetch list layouts
-            const params = new URLSearchParams();
-            params.set('sysparm_limit', '10');
-            params.set('sysparm_fields', 'sys_id,name,view,parent,active,sys_created_on,sys_updated_on');
-            params.set('sysparm_display_value', 'all');
-
-            const parts = [];
-            if (table) parts.push(`name=${table}`);
-            if (viewSysID) parts.push(`view=${viewSysID}`);
-            const sysparmQuery = parts.length > 0 ? `${parts.join('^')}^ORDERBYsys_created_on` : 'ORDERBYsys_created_on';
-            params.set('sysparm_query', sysparmQuery);
-
-            const records = await app.sdk.list('sys_ui_list', params);
-            if (records.length === 0) {
-              throw new Error(`no list layout found for ${table} with view "${viewName}"`);
-            }
-
-            const mainLayout = records[0];
-            const layoutSysID = getStringField(mainLayout, 'sys_id');
-
-            // Fetch elements (columns) for the list
-            const elemParams = new URLSearchParams();
-            elemParams.set('sysparm_limit', '100');
-            elemParams.set('sysparm_fields', 'sys_id,list_id,element,position,type');
-            elemParams.set('sysparm_display_value', 'all');
-            elemParams.set('sysparm_query', `list_id=${layoutSysID}^ORDERBYposition`);
-
-            const elemRecords = await app.sdk.list('sys_ui_list_element', elemParams);
-
-            const elements = elemRecords.map(record => ({
-              sys_id: getStringField(record, 'sys_id'),
-              listID: getStringField(record, 'list_id'),
-              element: getDisplayValue(record, 'element'),
-              position: getIntValue(record, 'position'),
-              type: getDisplayValue(record, 'type'),
-            }));
-
-            elements.sort((a, b) => a.position - b.position);
-
-            // Build formatted output
-            const lines = [];
-            lines.push('');
-            lines.push(chalk.bold(chalk.hex('#e8a217')(`${table} (${viewName})`)));
-            lines.push('');
-
-            lines.push(chalk.bold(chalk.hex('#666666')('─ List Columns ─')));
-            if (elements.length === 0) {
-              lines.push(chalk.hex('#888888')('  (no columns defined)'));
-            } else {
-              for (let i = 0; i < elements.length; i++) {
-                const elem = elements[i];
-                lines.push(`  ${chalk.hex('#666666')(`${String(i + 1).padStart(2)}.`)}  ${chalk.hex('#cccccc')(elem.element)}`);
-              }
-            }
-            lines.push('');
-
-            lines.push('─────');
-            lines.push('');
-            lines.push(chalk.bold(chalk.hex('#e8a217')('Hints:')));
-            lines.push(`  ${`jsn lists list ${table}`.padEnd(50)}  ${chalk.hex('#888888')('List all views')}`);
-            lines.push(`  ${`jsn forms show ${table} --view "${viewName}"`.padEnd(50)}  ${chalk.hex('#888888')('Show form layout')}`);
-            lines.push('');
-
-            const formatted = lines.join('\n');
-
-            // Build structured data for JSON/quiet mode
-            const columnsData = elements.map(elem => {
-              const col = {
-                element: elem.element,
-                position: elem.position,
-              };
-              if (elem.type) {
-                col.type = elem.type;
-              }
-              return col;
-            });
-
-            app.ok({
-              table,
-              view: viewName,
-              columns: columnsData,
-              _formatted: formatted,
-              _context: {
-                instance_url: app.getEffectiveInstance(),
-                table: 'sys_ui_list',
-              },
-            }, {
-              summary: `List: ${table} (${viewName}) - ${elements.length} columns`,
-              breadcrumbs: [
-                { action: 'list', cmd: `jsn lists list ${table}`, description: 'List all views' },
-                { action: 'form', cmd: `jsn forms show ${table} --view "${viewName}"`, description: 'Show form layout' },
-              ],
-            });
+            const vp = new URLSearchParams();
+            vp.set('sysparm_limit', '1'); vp.set('sysparm_fields', 'sys_id');
+            vp.set('sysparm_query', `name=${argv.view}^name=${table}`);
+            const vr = await app.sdk.list('sys_ui_view', vp);
+            viewSysID = vr.length > 0 ? getStringField(vr[0], 'sys_id') : '';
+
+            // Find list layout
+            const lp = new URLSearchParams();
+            lp.set('sysparm_limit', '1'); lp.set('sysparm_display_value', 'all');
+            lp.set('sysparm_fields', 'sys_id,name,view');
+            lp.set('sysparm_query', `name=${table}^view=${viewSysID || argv.view}`);
+            const layouts = await app.sdk.list('sys_ui_list', lp);
+            if (layouts.length === 0) throw new Error(`No list layout for ${table} view "${argv.view}"`);
+            await showList(app, table, getStringField(layouts[0], 'view') || argv.view, getStringField(layouts[0], 'sys_id'));
           }),
         });
     },
     handler: () => {
-      console.log('Manage list layouts from the sys_ui_list table.');
-      console.log('');
-      console.log('Available subcommands:');
-      console.log('  list <table>         List list views for a table');
-      console.log('  show <table>         Show list layout for a table');
+      console.log('Manage list layouts.');
       console.log('');
-      console.log('Run "jsn lists <command> --help" for details.');
+      console.log('Commands:');
+      console.log('  list [table]      List views (pick table if omitted)');
+      console.log('  show <table>      Show list layout columns');
     },
   };
 }
+
+async function showList(app, table, viewName, layoutSysID) {
+  const ep = new URLSearchParams();
+  ep.set('sysparm_limit', '100'); ep.set('sysparm_display_value', 'all');
+  ep.set('sysparm_fields', 'element,position,type');
+  ep.set('sysparm_query', `list_id=${layoutSysID}^ORDERBYposition`);
+  const elements = await app.sdk.list('sys_ui_list_element', ep);
+
+  elements.sort((a, b) => {
+    const pa = parseInt(getStringField(a, 'position') || '0', 10) || 0;
+    const pb = parseInt(getStringField(b, 'position') || '0', 10) || 0;
+    return pa - pb;
+  });
+
+  app.ok({
+    table,
+    view: viewName,
+    columns: elements.map(e => ({
+      element: getStringField(e, 'element'),
+      position: parseInt(getStringField(e, 'position') || '0', 10) || 0,
+      type: getStringField(e, 'type') || undefined,
+    })),
+    _context: { instance_url: app.getEffectiveInstance(), table: 'sys_ui_list' },
+  }, { summary: `${table} (${viewName}) — ${elements.length} columns` });
+}

package/src/commands/dev/restmessage.js

@@ -0,0 +1,32 @@
+import { buildDevCmd } from './_generic.js';
+import { getStringField } from '../../helpers.js';
+
+export const restmessageCmd = (wrap) => buildDevCmd('restmessage', 'sys_rest_message', ['rm', 'restmsg'],
+  ['name', 'endpoint', 'active', 'sys_scope'], wrap, {
+    singular: 'REST message',
+    scopeValidation: true,
+    onShow: async (record, app) => {
+      const sysID = getStringField(record, 'sys_id') || '';
+      if (!sysID) return;
+
+      // Fetch related methods
+      const mp = new URLSearchParams();
+      mp.set('sysparm_query', `rest_message=${sysID}^ORDERBYorder`);
+      mp.set('sysparm_limit', '100');
+      mp.set('sysparm_display_value', 'all');
+      mp.set('sysparm_fields', 'name,http_method,rest_endpoint,order,sys_id');
+      const methods = await app.sdk.list('sys_rest_message_fn', mp);
+
+      if (methods.length > 0) {
+        console.log(`  Methods (${methods.length}):`);
+        for (const m of methods) {
+          const name = getStringField(m, 'name') || getStringField(m, 'http_method') || '';
+          const method = getStringField(m, 'http_method') || '';
+          const path = getStringField(m, 'rest_endpoint') || '';
+          const mid = getStringField(m, 'sys_id') || '';
+          console.log(`    ${method} ${path}  (${name})`);
+          console.log(`      → jsn records get --table sys_rest_message_fn --sys-id ${mid}`);
+        }
+      }
+    },
+  });

package/src/commands/dev/soapmessages.js

@@ -0,0 +1,30 @@
+import { buildDevCmd } from './_generic.js';
+import { getStringField } from '../../helpers.js';
+
+export const soapmessagesCmd = (wrap) => buildDevCmd('soapmessages', 'sys_soap_message', ['soapmsg'],
+  ['name', 'active', 'sys_scope'], wrap, {
+    singular: 'SOAP message',
+    scopeValidation: true,
+    onShow: async (record, app) => {
+      const sysID = getStringField(record, 'sys_id') || '';
+      if (!sysID) return;
+
+      // Fetch related functions
+      const mp = new URLSearchParams();
+      mp.set('sysparm_query', `soap_message=${sysID}^ORDERBYorder`);
+      mp.set('sysparm_limit', '100');
+      mp.set('sysparm_display_value', 'all');
+      mp.set('sysparm_fields', 'name,order,sys_id');
+      const funcs = await app.sdk.list('sys_soap_message_function', mp);
+
+      if (funcs.length > 0) {
+        console.log(`  Functions (${funcs.length}):`);
+        for (const f of funcs) {
+          const name = getStringField(f, 'name') || '';
+          const fid = getStringField(f, 'sys_id') || '';
+          console.log(`    ${name}`);
+          console.log(`      → jsn records get --table sys_soap_message_function --sys-id ${fid}`);
+        }
+      }
+    },
+  });

package/src/commands/dev/uipolicies.js

@@ -0,0 +1,28 @@
+import { buildDevCmd } from './_generic.js';
+import { getStringField } from '../../helpers.js';
+
+export const uipoliciesCmd = (wrap) => buildDevCmd('uipolicies', 'sys_ui_policy', ['uipolicy', 'up'],
+  ['short_description', 'table', 'sys_class_name', 'active'], wrap, {
+    singular: 'UI policy',
+    scopeValidation: true,
+    onShow: async (record, app) => {
+      const sysID = getStringField(record, 'sys_id') || '';
+      if (!sysID) return;
+      const mp = new URLSearchParams();
+      mp.set('sysparm_query', `ui_policy=${sysID}^ORDERBYorder`);
+      mp.set('sysparm_limit', '100'); mp.set('sysparm_display_value', 'all');
+      mp.set('sysparm_fields', 'name,table,field_name,read_only,mandatory,visible,sys_id');
+      const actions = await app.sdk.list('sys_ui_policy_action', mp);
+      if (actions.length > 0) {
+        console.log(`  Actions (${actions.length}):`);
+        for (const a of actions) {
+          const f = getStringField(a, 'field_name') || '(all fields)';
+          const flags = [];
+          if (getStringField(a, 'mandatory') === 'true') flags.push('mandatory');
+          if (getStringField(a, 'read_only') === 'true') flags.push('read-only');
+          if (getStringField(a, 'visible') === 'false') flags.push('hidden');
+          console.log(`    ${f}  ${flags.length ? `[${flags.join(', ')}]` : ''}`);
+        }
+      }
+    },
+  });

package/src/commands/dev.js

@@ -7,7 +7,7 @@ import {
   spPagesCmd, spWidgetsCmd, uiPagesCmd, appMenuCmd,
   aclsCmd, rolesCmd, propertiesCmd,
   relationshipsCmd, appmodulesCmd, listcontrolsCmd, viewsCmd,
-  privilegesCmd, securitytypesCmd, uxscriptsCmd, aliasesCmd,
+  privilegesCmd, uxscriptsCmd, aliasesCmd,
   catalogscriptsCmd, cataloguipoliciesCmd,
 } from './dev/_simple.js';
 import { flowsCmd } from './dev/flows.js';
@@ -53,7 +53,6 @@ export function devCmd(wrap) {
         .command(listcontrolsCmd(wrap))
         .command(viewsCmd(wrap))
         .command(privilegesCmd(wrap))
-        .command(securitytypesCmd(wrap))
         .command(uxscriptsCmd(wrap))
         .command(aliasesCmd(wrap))
         .command(catalogscriptsCmd(wrap))

package/src/commands/groups.js

@@ -24,8 +24,30 @@ export function groupsCmd(wrap) {
               formatLabel: r => `${getStringField(r, 'name')} ${getStringField(r, 'manager') ? '→ ' + getStringField(r, 'manager') : ''}`,
             });
             if (picked) {
+              const sysID = getStringField(picked, 'sys_id') || '';
+              // Fetch member + role counts for hints
+              let memberCount = 0, roleCount = 0;
+              try {
+                const cp = new URLSearchParams();
+                cp.set('sysparm_query', `group=${sysID}`); cp.set('sysparm_limit', '0'); cp.set('sysparm_fields', 'sys_id');
+                const members = await app.sdk.list('sys_user_grmember', cp);
+                memberCount = members.length;
+              } catch {}
+              try {
+                const rp = new URLSearchParams();
+                rp.set('sysparm_query', `group=${sysID}`); rp.set('sysparm_limit', '0'); rp.set('sysparm_fields', 'sys_id');
+                const roles = await app.sdk.list('sys_group_has_role', rp);
+                roleCount = roles.length;
+              } catch {}
+
               picked._context = { instance_url: app.getEffectiveInstance(), table: 'sys_user_group' };
-              return app.ok(picked, { summary: `Group: ${getStringField(picked, 'name')}` });
+              return app.ok(picked, {
+                summary: `Group: ${getStringField(picked, 'name')}`,
+                breadcrumbs: [
+                  memberCount > 0 ? { action: 'members', cmd: `jsn records list --table sys_user_grmember --query "group=${sysID}"`, description: `${memberCount} member(s)` } : null,
+                  roleCount > 0 ? { action: 'roles', cmd: `jsn records list --table sys_group_has_role --query "group=${sysID}"`, description: `${roleCount} role(s)` } : null,
+                ].filter(Boolean),
+              });
             }
 
             const params = new URLSearchParams();

package/src/commands/users.js

@@ -24,8 +24,15 @@ export function usersCmd(wrap) {
               formatLabel: r => `${getStringField(r, 'user_name')} (${getStringField(r, 'name') || '-'})`,
             });
             if (picked) {
+              const sysID = getStringField(picked, 'sys_id') || '';
               picked._context = { instance_url: app.getEffectiveInstance(), table: 'sys_user' };
-              return app.ok(picked, { summary: `User: ${getStringField(picked, 'user_name')}` });
+              return app.ok(picked, {
+                summary: `User: ${getStringField(picked, 'user_name')}`,
+                breadcrumbs: [
+                  { action: 'preferences', cmd: `jsn records list --table sys_user_preference --query "user=${sysID}"`, description: 'User preferences' },
+                  { action: 'groups', cmd: `jsn records list --table sys_user_grmember --query "user=${sysID}"`, description: 'Group memberships' },
+                ],
+              });
             }
 
             const params = new URLSearchParams();

package/src/help.js

@@ -36,7 +36,6 @@ const AUTOMATION_COMMANDS = [
 
   { divider: '── In Memory ──' },
   { name: 'rules', alias: 'br', desc: 'Business rules (create, update, delete)' },
-  { name: 'workflows', desc: 'Workflow definitions' },
   { name: 'decisiontables', desc: 'Decision tables' },
   { name: 'assignments', desc: 'Assignment rules' },
 
@@ -46,9 +45,7 @@ const AUTOMATION_COMMANDS = [
 
   { divider: '── Outbound ──' },
   { name: 'restmessage', alias: 'rm', desc: 'REST Messages (sys_rest_message)' },
-  { name: 'restmethods', desc: 'REST Message methods (sys_rest_message_fn)' },
   { name: 'soapmessages', desc: 'SOAP Messages' },
-  { name: 'soapfunctions', desc: 'SOAP Message functions' },
 ];
 
 const ACCESS_COMMANDS = [
@@ -56,7 +53,6 @@ const ACCESS_COMMANDS = [
   { name: 'b4rules', alias: 'b4r', desc: 'Before-query business rules (see also Automation)' },
   { name: 'roles', alias: 'role', desc: 'Roles' },
   { name: 'privileges', alias: 'priv', desc: 'Scope privileges' },
-  { name: 'securitytypes', alias: 'st', desc: 'Custom security types' },
   { name: 'aliases', alias: 'als', desc: 'Connection & credential aliases' },
   { name: 'groups', alias: 'group', desc: 'Manage groups' },
   { name: 'groupmembers', alias: 'gm', desc: 'Group memberships' },

package/src/output.js

@@ -281,7 +281,7 @@ export class OutputWriter {
         const width = colWidths[col] || 20;
 
         if (j === 0 && instanceURL && table && row.sys_id) {
-          const url = `${instanceURL}/${table}.do?sys_id=${row.sys_id}`;
+          const url = getTableURL(instanceURL, table, row.sys_id);
           val = hyperlink(val, url);
         }
 
@@ -291,7 +291,7 @@ export class OutputWriter {
           display = visible.slice(0, width - 3) + '...';
           if (val !== visible) {
             if (j === 0 && instanceURL && table && row.sys_id) {
-              const url = `${instanceURL}/${table}.do?sys_id=${row.sys_id}`;
+              const url = getTableURL(instanceURL, table, row.sys_id);
               display = hyperlink(display, url);
             }
           }
@@ -417,7 +417,7 @@ export class OutputWriter {
       const sysID = getDisplayValue(data.sys_id);
       if (sysID) {
         const urlTable = table.toLowerCase().replace(/\s+/g, '_');
-        const recordURL = `${instanceURL}/${urlTable}.do?sys_id=${sysID}`;
+        const recordURL = getTableURL(instanceURL, urlTable, sysID);
         this.writer.write(`Link:  ${recordURL}\n\n`);
       }
     }
@@ -453,6 +453,21 @@ function detectRecord(data) {
   return { isRecord: hasSysID && (hasSysClass || tableName), tableName };
 }
 
+export function getTableURL(instance, table, sysID) {
+  const mapped = {
+    sys_decision: `now/workflow-studio/builder?table=sys_decision&sysId=${sysID}`,
+    sys_rest_message: `nav_to.do?uri=sys_rest_message.do?sys_id=${sysID}`,
+    sysevent_email_action: `nav_to.do?uri=sysevent_email_action.do?sys_id=${sysID}`,
+    sysevent_in_email_action: `nav_to.do?uri=sysevent_in_email_action.do?sys_id=${sysID}`,
+    soap_message: `nav_to.do?uri=soap_message.do?sys_id=${sysID}`,
+    sys_security_acl: `nav_to.do?uri=sys_security_acl.do?sys_id=${sysID}`,
+    sys_user_role: `nav_to.do?uri=sys_user_role.do?sys_id=${sysID}`,
+    sys_db_object: `nav_to.do?uri=sys_db_object.do?sys_id=${sysID}`,
+  };
+  const path = mapped[table] || `${table}.do?sys_id=${sysID}`;
+  return `${instance}/${path}`;
+}
+
 export function getDisplayValue(val) {
   if (val == null) return '';
   if (typeof val === 'string') return val;

package/src/paginated-search.js

@@ -4,16 +4,10 @@
 
 import { createPrompt, useState, useKeypress, usePagination, useEffect, useRef } from '@inquirer/core';
 import { isEnterKey, isUpKey, isDownKey } from '@inquirer/core';
-import { appendFileSync } from 'fs';
 
 export const paginatedSearch = createPrompt((config, done) => {
   const { message, pageSize = 10, totalCount = 0, source } = config;
 
-  // ── DEBUG ──
-  const DBG = '/home/jace/workspace/holly/sn-jsn-fork/debug.log';
-  const log = (msg) => appendFileSync(DBG, `${new Date().toISOString()} ${msg}\n`);
-  log(`START totalCount=${totalCount}`);
-
   const [status, setStatus] = useState('loading');
   const [searchTerm, setSearchTerm] = useState('');
   const [choices, setChoices] = useState([]);
@@ -36,12 +30,10 @@ export const paginatedSearch = createPrompt((config, done) => {
   useEffect(() => {
     const controller = new AbortController();
     setStatus('loading');
-    log(`EFFECT-INIT searchTerm="${searchTerm}"`);
 
     const load = async () => {
       try {
         const items = await source(searchTerm || undefined, 0, { signal: controller.signal });
-        log(`INIT-LOAD got ${items.length} items`);
         if (!controller.signal.aborted) {
           choicesRef.current = items;
           loadedRef.current = items.length;
@@ -52,7 +44,6 @@ export const paginatedSearch = createPrompt((config, done) => {
           setStatus('done');
         }
       } catch (err) {
-        log(`INIT-LOAD error: ${err.message}`);
         if (!controller.signal.aborted) {
           setStatus('done');
           setChoices([]);
@@ -66,16 +57,10 @@ export const paginatedSearch = createPrompt((config, done) => {
 
   // Load more when scrolling past end
   async function loadMore() {
-    log(`loadMore check: loaded=${loadedRef.current} total=${totalCountRef.current} searchMode=${searchModeRef.current}`);
-    if (loadedRef.current >= totalCountRef.current || searchModeRef.current) {
-      log(`loadMore SKIPPED`);
-      return;
-    }
+    if (loadedRef.current >= totalCountRef.current || searchModeRef.current) return;
     setStatus('loading');
-    log(`loadMore calling source offset=${loadedRef.current}`);
     try {
       const newItems = await source('', loadedRef.current, { signal: new AbortController().signal });
-      log(`loadMore got ${newItems.length} items`);
       const updated = choicesRef.current.concat(newItems);
       choicesRef.current = updated;
       loadedRef.current = updated.length;
@@ -166,7 +151,6 @@ export const paginatedSearch = createPrompt((config, done) => {
         activeRef.current++;
         setActive(activeRef.current);
       } else if (!searchModeRef.current && loadedRef.current < totalCountRef.current) {
-        log(`DOWN at end: active=${activeRef.current} len=${choicesRef.current.length} loaded=${loadedRef.current} total=${totalCountRef.current}`);
         loadMore().then(() => {
           activeRef.current++;
           setActive(activeRef.current);

package/src/sdk.js

@@ -139,10 +139,6 @@ export class SDKClient {
   async list(table, params = {}) {
     const query = new URLSearchParams(params).toString();
     const endpoint = `${this.baseURL}/api/now/table/${table}${query ? '?' + query : ''}`;
-    // Debug: log paginated queries
-    if (params.sysparm_offset) {
-      process.stderr.write(`[SDK list] offset=${params.sysparm_offset} limit=${params.sysparm_limit} table=${table}\n`);
-    }
     const result = await this.request(endpoint, { method: 'GET' });
     return result?.result || [];
   }