@jacebenson/jsn 3.0.1 → 3.0.3

package/package.json

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

package/src/app.js

@@ -7,6 +7,7 @@ import { getEffectiveInstance } from './config.js';
 import { extractProfileName } from './helpers.js';
 import { getCurrentUser, getCurrentApplication, getCurrentUpdateSet } from './context.js';
 import { errUsage, errAuth } from './errors.js';
+import { isMutationCommand } from './mutations.js';
 import process from 'node:process';
 
 
@@ -57,7 +58,7 @@ export class App {
     return getEffectiveInstance(this.config);
   }
 
-  async printContextHeader() {
+  async printContextHeader(argv = {}) {
     if (!this.getEffectiveInstance() || !this.sdk) return;
     if (process.env.JSN_NO_HEADER) return;
     if (this.output.getFormat() === FormatJSON || this.output.getFormat() === FormatQuiet) return;
@@ -127,8 +128,10 @@ export class App {
 
     process.stderr.write(`${profileStr} ${userStr} ${scopeStr} ${updateSetStr}\n\n`);
 
-    // ⚠️  Warning if in the Default update set
-    if (updateSet && updateSet.toLowerCase().includes('default')) {
+    // ⚠️  Warning if in the Default update set (mutation commands only)
+    const profile = this.context.profileName ? this.config.profiles[this.context.profileName] : null;
+    const isYolo = profile?.yolo === true;
+    if (!isYolo && isMutationCommand(argv) && updateSet && updateSet.toLowerCase().includes('default')) {
       const isGlobal = scope === 'global';
       if (isGlobal) {
         // 🔴 HARD WARNING — Global + Default
@@ -146,7 +149,7 @@ export class App {
           '┃  Or switch to a scoped scope first:                    ┃\n' +
           '┃    jsn dev scopes list                                 ┃\n' +
           '┃                                                        ┃\n' +
-          '┃  (Run jsn updatesets yolo to silence this check)       ┃\n' +
+          '┃  (Run jsn dev updatesets yolo to silence this check)    ┃\n' +
           '┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\x1b[0m\n'
         );
       } else {
@@ -157,7 +160,7 @@ export class App {
           '  ⚠  Default update set in scope [' + scope + ']\n' +
           '  Changes are contained to this scope, but a named\n' +
           '  update set is still recommended for tracking.\n' +
-          '  (Run \x1b[1mjsn updatesets yolo\x1b[22m to silence this warning)\n' +
+          '  (Run \x1b[1mjsn dev updatesets yolo\x1b[22m to silence this warning)\n' +
           '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
           '\x1b[0m' // reset
         );

package/src/cli.js

@@ -156,7 +156,7 @@ export const cli = yargs(hideBin(process.argv))
 
     // Print context header for interactive terminals (at the TOP, before command output)
     if (!['help', 'version', 'completion', 'skill'].includes(cmd)) {
-      await argv.app.printContextHeader();
+      await argv.app.printContextHeader(argv);
     }
   })
   .command(setupCmd(wrap))
@@ -185,6 +185,25 @@ export const cli = yargs(hideBin(process.argv))
     if (err) throw err;
     // No command given → show custom grouped help instead of yargs error
     if (msg === 'You must specify a command') {
+      // Check if --profile/-p was used without a value — show profile info instead
+      const raw = process.argv.slice(2);
+      const hasLoneProfile = raw.some((a, i, arr) => {
+        if (a !== '--profile' && a !== '-p') return false;
+        const next = arr[i + 1];
+        return !next || next.startsWith('-');
+      });
+      if (hasLoneProfile) {
+        const cfg = loadConfig();
+        const activeName = cfg.activeProfile || cfg.defaultProfile;
+        process.stdout.write('Profiles:\n');
+        for (const [name, p] of Object.entries(cfg.profiles || {})) {
+          const marker = name === activeName ? ' *' : '  ';
+          process.stdout.write(`  ${marker} ${name.padEnd(20)} ${p.instance_url || ''}\n`);
+        }
+        process.stdout.write('\nUsage: jsn --profile <name> <command>\n');
+        process.stdout.write('       jsn profiles use <name>\n');
+        process.exit(0);
+      }
       process.stdout.write(renderHelp());
       process.exit(0);
     }

package/src/commands/dev/_generic.js

@@ -54,6 +54,28 @@ async function checkScope(sdk, recordScope) {
   return { currentScope, recordScope };
 }
 
+/**
+ * Resolve the API scope name from a record's sys_scope reference field.
+ * With sysparm_display_value=all, sys_scope is { display_value: "Name", value: "<sys_id>" }.
+ * getStringField returns the display_value (human-readable), but we need the API name
+ * (e.g. "x_example_app") to compare against getCurrentScope().
+ */
+async function resolveRecordScope(sdk, record) {
+  const sysScope = record['sys_scope'];
+  let scopeId;
+  if (sysScope && typeof sysScope === 'object' && sysScope.value) {
+    scopeId = sysScope.value;
+  } else {
+    return getStringField(record, 'sys_scope');
+  }
+  try {
+    const scopeRecord = await sdk.get('sys_scope', scopeId);
+    return scopeRecord?.scope || 'global';
+  } catch {
+    return getStringField(record, 'sys_scope');
+  }
+}
+
 export function buildDevCmd(name, table, aliases, defaultColumns, wrap, opts = {}) {
   const showFields = opts.showFields !== undefined ? opts.showFields : null;
   const singular = toSingular(name, opts.singular);
@@ -257,7 +279,7 @@ export function buildDevCmd(name, table, aliases, defaultColumns, wrap, opts = {
               throw new Error(`${singular} not found: ${id}`);
             }
             const sysID = getStringField(records[0], 'sys_id');
-            const recordScope = getStringField(records[0], 'sys_scope');
+            const recordScope = await resolveRecordScope(app.sdk, records[0]);
 
             if (scopeValidation) {
               const scopeErr = await checkScope(app.sdk, recordScope);
@@ -288,7 +310,7 @@ export function buildDevCmd(name, table, aliases, defaultColumns, wrap, opts = {
             }
             const sysID = getStringField(records[0], 'sys_id');
             const recordName = getStringField(records[0], 'name') || id;
-            const recordScope = getStringField(records[0], 'sys_scope');
+            const recordScope = await resolveRecordScope(app.sdk, records[0]);
 
             if (scopeValidation) {
               const scopeErr = await checkScope(app.sdk, recordScope);

package/src/commands/dev/_simple.js

@@ -79,11 +79,23 @@ export const columnsCmd = (wrap) => buildDevCmd('columns', 'sys_dictionary', ['c
 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 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', readOnly: true });
-export const appMenuCmd = (wrap) => buildDevCmd('appmenu', 'sys_app_application', ['app-menu', 'menu'], ['name', 'active', 'sys_scope'], wrap, { singular: 'application menu', readOnly: true });
+export const uiPagesCmd = (wrap) => buildDevCmd('uipages', 'sys_ui_page', ['ui-page', 'pages'], ['name', 'sys_scope'], wrap, { singular: 'UI page', scopeValidation: true });
+export const appMenuCmd = (wrap) => buildDevCmd('appmenu', 'sys_app_application', ['app-menu', 'menu'], ['name', 'active', 'sys_scope'], wrap, { singular: 'application menu', scopeValidation: true });
 export const scRAPICmd = (wrap) => buildDevCmd('scrapi', 'sys_ws_operation', ['scripted-rest', 'rest-api'], ['name', 'sys_ws_definition', 'sys_scope'], wrap, { singular: 'scripted REST API', readOnly: true });
 
 // Commands with full CRUD
-export const aclsCmd = (wrap) => buildDevCmd('acls', 'sys_security_acl', ['acl'], ['name', 'operation', 'type', 'active', 'sys_scope'], wrap, { singular: 'ACL', readOnly: true });
+export const aclsCmd = (wrap) => buildDevCmd('acls', 'sys_security_acl', ['acl'], ['name', 'operation', 'type', 'active', 'sys_scope'], wrap, { singular: 'ACL', scopeValidation: true });
 export const rolesCmd = (wrap) => buildDevCmd('roles', 'sys_user_role', ['role', 'r'], ['name', 'description', 'elevated_privilege', 'sys_scope'], wrap, { singular: 'role', scopeValidation: true });
-export const propertiesCmd = (wrap) => buildDevCmd('properties', 'sys_properties', ['property', 'prop'], ['name', 'value', 'description', 'sys_scope'], wrap, { singular: 'property', readOnly: true });
+export const propertiesCmd = (wrap) => buildDevCmd('properties', 'sys_properties', ['property', 'prop'], ['name', 'value', 'description', 'sys_scope'], wrap, { singular: 'property', scopeValidation: true });
+
+// New commands for scoped-app tables
+export const relationshipsCmd = (wrap) => buildDevCmd('relationships', 'sys_relationship', ['relationship', 'rel'], ['name', 'sys_scope'], wrap, { singular: 'relationship', scopeValidation: true });
+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 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 const catalogscriptsCmd = (wrap) => buildDevCmd('catalogscripts', 'catalog_script_client', ['catalogscript', 'cs'], ['name', 'table', 'active', 'sys_scope'], wrap, { singular: 'catalog script', scopeValidation: 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 });

package/src/commands/dev/eval.js

@@ -6,8 +6,8 @@ export function evalCmd(wrap) {
     describe: 'Execute background scripts on the instance',
     builder: (yargs) => {
       return yargs
-        .option('script', { alias: 's', type: 'string', describe: 'JavaScript code to execute' })
-        .option('file', { alias: 'f', type: 'string', describe: 'Read script from file' });
+        .option('script', { alias: 's', type: 'string', describe: "JavaScript code to execute (single-quote the script, double quotes inside: --script 'gs.log(\"Hello\")')" })
+        .option('file', { alias: 'f', type: 'string', describe: 'Read script from file (avoids shell quoting issues)' });
     },
     handler: wrap(async (argv, app) => {
       let script;

package/src/commands/dev/flows.js

@@ -25,7 +25,7 @@ export function flowsCmd(wrap) {
               formatLabel: r => `${getStringField(r, 'name')} ${getStringField(r, 'active') === 'true' ? '' : '[inactive]'}`,
             });
             if (picked) {
-              const inspection = await app.sdk.inspectFlow(picked.sys_id);
+              const inspection = await app.sdk.inspectFlow(getStringField(picked, 'sys_id'));
               const formatted = formatFlowInspection(inspection, app.getEffectiveInstance());
               return app.ok({ ...inspection, _formatted: formatted }, {
                 summary: `Flow: ${inspection.flow.name}`,

package/src/commands/dev/forms.js

@@ -54,6 +54,10 @@ export function formsCmd(wrap) {
           aliases: ['ls'],
           describe: 'List form views for a table',
           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' }),
           handler: wrap(async (argv, app) => {
             const table = argv.table;

package/src/commands/dev/lists.js

@@ -45,6 +45,10 @@ export function listsCmd(wrap) {
           aliases: ['ls'],
           describe: 'List list views for a table',
           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' }),
           handler: wrap(async (argv, app) => {
             const table = argv.table;

package/src/commands/dev/scopes.js

@@ -47,14 +47,24 @@ export function scopesCmd(wrap) {
         .command({
           command: 'show <scope>',
           aliases: ['get'],
-          describe: 'Show a scope',
+          describe: 'Show a scope by scope value or name',
+          builder: (y) => y
+            .positional('scope', {
+              describe: 'Scope value (e.g. x_417611_daves_o_0) or display name',
+              type: 'string',
+            }),
           handler: wrap(async (argv, app) => {
-            const params = new URLSearchParams();
-            params.set('sysparm_query', `scope=${argv.scope}`);
-            params.set('sysparm_limit', '1');
-            params.set('sysparm_display_value', 'all');
-            const records = await app.sdk.list('sys_scope', params);
-            if (records.length === 0) {
+            let records;
+            // Try by scope value first, then by name
+            for (const queryField of ['scope', 'name']) {
+              const params = new URLSearchParams();
+              params.set('sysparm_query', `${queryField}=${argv.scope}`);
+              params.set('sysparm_limit', '1');
+              params.set('sysparm_display_value', 'all');
+              records = await app.sdk.list('sys_scope', params);
+              if (records.length > 0) break;
+            }
+            if (!records || records.length === 0) {
               throw new Error(`Scope not found: ${argv.scope}`);
             }
             app.ok(records[0], { summary: `Scope ${argv.scope}` });

package/src/commands/dev/updatesets.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import { formatRecordForDisplay, getStringField, interactiveList } from '../../helpers.js';
 
 export function updateSetsCmd(wrap) {
@@ -162,6 +163,55 @@ export function updateSetsCmd(wrap) {
             });
           }),
         })
+        .command({
+          command: 'yolo',
+          aliases: ['silence'],
+          describe: 'Silence the "Default update set" warning for this profile',
+          handler: wrap(async (argv, app) => {
+            const name = app.context.profileName;
+            if (!name) {
+              throw new Error('No active profile to mark as yolo. Run jsn setup first.');
+            }
+            app.config.profiles[name].yolo = true;
+            const { saveConfig } = await import('../../config.js');
+            saveConfig(app.config);
+            app.ok({ profile: name, yolo: true }, { summary: 'Default update set warning silenced for this profile' });
+          }),
+        })
+        .command({
+          command: 'export <name>',
+          describe: 'Export an update set to XML',
+          builder: (y) => y
+            .positional('name', {
+              describe: 'Update set name',
+              type: 'string',
+            })
+            .option('output', {
+              alias: 'o',
+              type: 'string',
+              describe: 'Output file path (default: stdout)',
+            }),
+          handler: wrap(async (argv, app) => {
+            const params = new URLSearchParams();
+            params.set('sysparm_query', `name=${argv.name}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_fields', 'sys_id,name');
+            const records = await app.sdk.list('sys_update_set', params);
+            if (records.length === 0) {
+              throw new Error(`Update set not found: ${argv.name}`);
+            }
+            const sysID = getStringField(records[0], 'sys_id');
+            const instance = app.getEffectiveInstance();
+            const url = `${instance}/sys_update_set.do?XML&sysparm_sys_id=${sysID}`;
+            const xml = await app.sdk.rawRequest(url, { method: 'GET' });
+            if (argv.output) {
+              fs.writeFileSync(argv.output, xml, 'utf-8');
+              app.ok({ name: argv.name, sys_id: sysID, output: argv.output }, { summary: `Exported update set to ${argv.output}` });
+            } else {
+              process.stdout.write(xml + '\n');
+            }
+          }),
+        })
 
     },
     handler: (argv) => {
@@ -172,6 +222,7 @@ export function updateSetsCmd(wrap) {
         console.log('  show <name>    Show an update set');
         console.log('  set  <name>    Set the current update set');
         console.log('  create         Create a new update set (auto-sets as current)');
+        console.log('  export <name>  Export an update set to XML');
         console.log('  complete <name>  Mark an update set as complete (coming soon)');
         console.log('  yolo           Silence the "Default update set" warning');
         console.log('\nRun "jsn dev updatesets <command> --help" for details.');

package/src/commands/dev.js

@@ -6,6 +6,9 @@ import {
   tablesCmd, columnsCmd, importCmd,
   spPagesCmd, spWidgetsCmd, uiPagesCmd, appMenuCmd, scRAPICmd,
   aclsCmd, rolesCmd, propertiesCmd,
+  relationshipsCmd, appmodulesCmd, listcontrolsCmd, viewsCmd,
+  privilegesCmd, securitytypesCmd, uxscriptsCmd, aliasesCmd,
+  catalogscriptsCmd, cataloguipoliciesCmd,
 } from './dev/_simple.js';
 import { flowsCmd } from './dev/flows.js';
 import { formsCmd } from './dev/forms.js';
@@ -44,6 +47,16 @@ export function devCmd(wrap) {
         .command(updateSetsCmd(wrap))
         .command(scopesCmd(wrap))
         .command(propertiesCmd(wrap))
+        .command(relationshipsCmd(wrap))
+        .command(appmodulesCmd(wrap))
+        .command(listcontrolsCmd(wrap))
+        .command(viewsCmd(wrap))
+        .command(privilegesCmd(wrap))
+        .command(securitytypesCmd(wrap))
+        .command(uxscriptsCmd(wrap))
+        .command(aliasesCmd(wrap))
+        .command(catalogscriptsCmd(wrap))
+        .command(cataloguipoliciesCmd(wrap))
         .command(logsCmd(wrap))
         .command(evalCmd(wrap))
         .command(restCmd(wrap));

package/src/commands/profiles.js

@@ -181,6 +181,9 @@ export function profilesCmd(wrap) {
         console.log('  use  <name>    Switch to a different profile');
         console.log('  remove <name>  Remove a profile');
         console.log('\nRun "jsn profiles <command> --help" for more details.');
+        console.log('\nNote: You can also create a profile by authenticating:');
+        console.log('  jsn auth login --profile <name> <instance-url>');
+        console.log('  jsn auth login --profile staging --password https://dev12345.service-now.com');
       }
     },
   };

package/src/commands/records.js

@@ -165,6 +165,34 @@ export function recordsCmd(wrap) {
             app.ok({ message: 'Record deleted', table: argv.table, sys_id: argv['sys-id'] }, { summary: `Deleted record from ${argv.table}` });
           }),
         })
+        .command({
+          command: 'inspect <table> <identifier>',
+          aliases: ['debug', 'diag'],
+          describe: 'Inspect a record: show audit history, business rules, and running flows',
+          builder: (y) => y
+            .positional('table', { describe: 'Table name (e.g. incident)', type: 'string' })
+            .positional('identifier', { describe: 'Record sys_id or number', type: 'string' }),
+          handler: wrap(async (argv, app) => {
+            const { inspectRecord, formatInspectOutput } = await import('../records/inspect.js');
+            const result = await inspectRecord(app, argv.table, argv.identifier);
+            const breadcrumbs = [
+              ...result.flows.map(f => ({
+                action: 'show',
+                cmd: `jsn dev flows show "${f.flow}"`,
+                description: `View flow details for ${f.flow}`,
+              })),
+              ...result.businessRules.slice(0, 5).map(br => ({
+                action: 'show',
+                cmd: `jsn dev rules show "${br.name}"`,
+                description: `View business rule: ${br.name}`,
+              })),
+            ];
+            app.ok({ ...result, _formatted: formatInspectOutput(result) }, {
+              summary: `Inspected ${argv.table} ${argv.identifier}`,
+              breadcrumbs,
+            });
+          }),
+        })
 
     },
     handler: () => {},

package/src/commands/tickets.js

@@ -26,7 +26,7 @@ export function ticketsCmd(wrap) {
             if (fields) params.set('sysparm_fields', fields);
             const q = argv.query ? argv.query + '^ORDERBYDESCsys_updated_on' : 'ORDERBYDESCsys_updated_on';
             params.set('sysparm_query', q);
-            const records = await app.sdk.list('ticket', params);
+            const records = await app.sdk.list('task', params);
             const displayRecords = fields ? records.map(r => formatRecordForDisplay(r, columns)) : records;
             const breadcrumbs = [
               { action: 'create', cmd: 'jsn tickets create --data \'{...}\'', description: 'Create a new ticket' },
@@ -46,7 +46,7 @@ export function ticketsCmd(wrap) {
               });
             }
             app.ok({
-              table: 'ticket',
+              table: 'task',
               count: records.length,
               columns,
               records: displayRecords,
@@ -64,7 +64,7 @@ export function ticketsCmd(wrap) {
             params.set('sysparm_query', `number=${argv.number}`);
             params.set('sysparm_limit', '1');
             params.set('sysparm_display_value', 'all');
-            const records = await app.sdk.list('ticket', params);
+            const records = await app.sdk.list('task', params);
             if (records.length === 0) {
               throw new Error(`Ticket not found: ${argv.number}`);
             }
@@ -77,7 +77,7 @@ export function ticketsCmd(wrap) {
           builder: (y) => y.option('data', { type: 'string', demandOption: true, describe: 'JSON fields (e.g. \'{"state":"2","priority":"1"}\')' }),
           handler: wrap(async (argv, app) => {
             const recordData = JSON.parse(argv.data);
-            const record = await app.sdk.create('ticket', recordData);
+            const record = await app.sdk.create('task', recordData);
             app.ok(record, { summary: `Created ticket ${getStringField(record, 'number')}` });
           }),
         })
@@ -90,12 +90,12 @@ export function ticketsCmd(wrap) {
             const findParams = new URLSearchParams();
             findParams.set('sysparm_query', `number=${argv.number}`);
             findParams.set('sysparm_limit', '1');
-            const records = await app.sdk.list('ticket', findParams);
+            const records = await app.sdk.list('task', findParams);
             if (records.length === 0) {
               throw new Error(`Ticket not found: ${argv.number}`);
             }
             const sysID = getStringField(records[0], 'sys_id');
-            const updated = await app.sdk.update('ticket', sysID, recordData);
+            const updated = await app.sdk.update('task', sysID, recordData);
             app.ok(updated, { summary: `Updated ticket ${argv.number}` });
           }),
         })
@@ -106,12 +106,12 @@ export function ticketsCmd(wrap) {
             const findParams = new URLSearchParams();
             findParams.set('sysparm_query', `number=${argv.number}`);
             findParams.set('sysparm_limit', '1');
-            const records = await app.sdk.list('ticket', findParams);
+            const records = await app.sdk.list('task', findParams);
             if (records.length === 0) {
               throw new Error(`Ticket not found: ${argv.number}`);
             }
             const sysID = getStringField(records[0], 'sys_id');
-            await app.sdk.delete('ticket', sysID);
+            await app.sdk.delete('task', sysID);
             app.ok({ number: argv.number, message: 'Ticket deleted' }, { summary: `Deleted ticket ${argv.number}` });
           }),
         })

package/src/helpers.js

@@ -143,6 +143,8 @@ export function parseDataArg(argv) {
   let raw;
   if (argv['data-file']) {
     raw = fs.readFileSync(argv['data-file'], 'utf-8');
+    // Strip UTF-8 BOM (\ufeff) which some editors (Windows/PowerShell) add
+    if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1);
   } else if (argv.data) {
     raw = argv.data;
   } else {

package/src/mutations.js

@@ -23,11 +23,32 @@ export const MUTATION_COMMANDS = [
   ['tasks', 'create'],
   ['tasks', 'update'],
   ['tasks', 'delete'],
-  // Dev
+  // Tickets
+  ['tickets', 'create'],
+  ['tickets', 'update'],
+  ['tickets', 'delete'],
+  // Users
+  ['users', 'create'],
+  ['users', 'update'],
+  ['users', 'delete'],
+  // Groups
+  ['groups', 'create'],
+  ['groups', 'update'],
+  ['groups', 'delete'],
+  // Catalog
+  ['catalog', 'create-item'],
+  // Dev flows
+  ['dev', 'flows', 'create'],
+  ['dev', 'flows', 'update'],
+  ['dev', 'flows', 'delete'],
+  // Dev scopes
+  ['dev', 'scopes', 'create'],
+  ['dev', 'scopes', 'set'],
+  // Dev eval
   ['dev', 'eval'],
+  // Dev updatesets
   ['dev', 'updatesets', 'set'],
   ['dev', 'updatesets', 'create'],
-  ['dev', 'scopes', 'set'],
 ];
 
 /**

package/src/records/inspect.js

@@ -0,0 +1,266 @@
+import { isHexString, getStringField } from '../helpers.js';
+
+export async function resolveIdentifier(app, table, identifier) {
+  // If it looks like a sys_id (32 hex chars), use it directly
+  if (isHexString(identifier) && identifier.length === 32) {
+    return identifier;
+  }
+
+  // Otherwise, assume it's a record number — query the table
+  const params = new URLSearchParams();
+  params.set('sysparm_query', `number=${identifier}`);
+  params.set('sysparm_limit', '1');
+  params.set('sysparm_fields', 'sys_id');
+  const records = await app.sdk.list(table, params);
+  if (records.length === 0) {
+    throw new Error(`Record not found in ${table}: ${identifier}`);
+  }
+  return getStringField(records[0], 'sys_id');
+}
+
+async function fetchHistory(app, table, sysId, limit = 20) {
+  const params = new URLSearchParams();
+  params.set('sysparm_query', `documentkey=${sysId}^tablename=${table}`);
+  params.set('sysparm_limit', String(limit));
+  params.set('sysparm_fields', 'fieldname,newvalue,oldvalue,sys_created_on,sys_created_by');
+  params.set('sysparm_display_value', 'all');
+  params.set('sysparm_order_by', 'sys_created_on');
+  const records = await app.sdk.list('sys_audit', params);
+  return records.map(r => ({
+    field: r.fieldname?.display_value || r.fieldname,
+    oldValue: (r.oldvalue?.display_value ?? r.oldvalue?.value ?? '') || '',
+    newValue: (r.newvalue?.display_value ?? r.newvalue?.value ?? '') || '',
+    _oldRaw: r.oldvalue?.value ?? r.oldvalue ?? '',
+    _newRaw: r.newvalue?.value ?? r.newvalue ?? '',
+    changedOn: r.sys_created_on?.display_value || r.sys_created_on,
+    changedBy: r.sys_created_by?.display_value || r.sys_created_by,
+  }));
+}
+
+// Known choice fields and their display labels from sys_choice
+const CHOICE_FIELDS = new Set(['state', 'incident_state', 'priority', 'impact', 'urgency', 'active', 'category', 'subcategory']);
+
+// Known sys_user reference fields
+const USER_REF_FIELDS = new Set(['closed_by', 'assigned_to', 'opened_by', 'resolved_by', 'called_by', 'caller_id']);
+
+// Boolean fields stored as 0/1 in sys_audit
+const BOOL_FIELDS = new Set(['active']);
+
+async function resolveHistoryDisplayValues(app, table, history) {
+  // Collect unique sys_ids for user reference resolution
+  const userSysIds = new Set();
+  for (const h of history) {
+    if (USER_REF_FIELDS.has(h.field)) {
+      if (isHexString(h.oldValue) && h.oldValue.length === 32) userSysIds.add(h.oldValue);
+      if (isHexString(h.newValue) && h.newValue.length === 32) userSysIds.add(h.newValue);
+    }
+  }
+
+  // Batch lookup user names
+  const userNameMap = new Map();
+  if (userSysIds.size > 0) {
+    const idList = [...userSysIds].join(',');
+    const params = new URLSearchParams();
+    params.set('sysparm_query', `sys_idIN${idList}`);
+    params.set('sysparm_limit', '100');
+    params.set('sysparm_fields', 'sys_id,name');
+    params.set('sysparm_display_value', 'all');
+    try {
+      const users = await app.sdk.list('sys_user', params);
+      for (const u of users) {
+        const uid = getStringField(u, 'sys_id');
+        const name = u.name?.display_value || u.name;
+        if (uid && name) userNameMap.set(uid, name);
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  // Collect unique (field, value) pairs for choice resolution
+  const choiceLookups = new Set();
+  for (const h of history) {
+    if (CHOICE_FIELDS.has(h.field)) {
+      if (h.oldValue && h.oldValue !== '_raw_old_') choiceLookups.add(`${h.field}|${h.oldValue}`);
+      if (h.newValue && h.newValue !== '_raw_new_') choiceLookups.add(`${h.field}|${h.newValue}`);
+    }
+  }
+
+  // Batch lookup choice labels
+  const choiceLabelMap = new Map();
+  if (choiceLookups.size > 0) {
+    for (const key of choiceLookups) {
+      const [field, val] = key.split('|');
+      const params = new URLSearchParams();
+      params.set('sysparm_query', `name=${table}^element=${field}^value=${val}^language=en`);
+      params.set('sysparm_limit', '1');
+      params.set('sysparm_fields', 'value,label');
+      params.set('sysparm_display_value', 'all');
+      try {
+        const choices = await app.sdk.list('sys_choice', params);
+        if (choices.length > 0) {
+          const label = choices[0].label?.display_value || choices[0].label;
+          if (label) choiceLabelMap.set(key, label);
+        }
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  // Apply resolutions to history entries
+  return history.map(h => {
+    let oldDisplay = h.oldValue;
+    let newDisplay = h.newValue;
+
+    // Resolve user references
+    if (USER_REF_FIELDS.has(h.field)) {
+      if (isHexString(oldDisplay) && oldDisplay.length === 32) {
+        oldDisplay = userNameMap.get(oldDisplay) || oldDisplay || '(empty)';
+      }
+      if (isHexString(newDisplay) && newDisplay.length === 32) {
+        newDisplay = userNameMap.get(newDisplay) || newDisplay || '(empty)';
+      }
+    }
+
+    // Resolve choice labels
+    if (CHOICE_FIELDS.has(h.field)) {
+      const oldLabel = choiceLabelMap.get(`${h.field}|${h.oldValue}`);
+      const newLabel = choiceLabelMap.get(`${h.field}|${h.newValue}`);
+      if (oldLabel) oldDisplay = oldLabel;
+      if (newLabel) newDisplay = newLabel;
+    }
+
+    // Resolve boolean fields
+    if (BOOL_FIELDS.has(h.field)) {
+      if (oldDisplay === '1') oldDisplay = 'Yes';
+      else if (oldDisplay === '0') oldDisplay = 'No';
+      if (newDisplay === '1') newDisplay = 'Yes';
+      else if (newDisplay === '0') newDisplay = 'No';
+    }
+
+    return { ...h, oldValue: oldDisplay || '(empty)', newValue: newDisplay || '(empty)' };
+  });
+}
+
+async function fetchBusinessRules(app, table) {
+  const params = new URLSearchParams();
+  params.set('sysparm_query', `collection=${table}^active=true`);
+  params.set('sysparm_limit', '50');
+  params.set('sysparm_fields', 'name,collection,order,active,sys_scope,when,filter_condition');
+  params.set('sysparm_display_value', 'all');
+  params.set('sysparm_order_by', 'order');
+  const records = await app.sdk.list('sys_script', params);
+  return records
+    .map(r => ({
+      name: r.name?.display_value || r.name,
+      order: r.order?.display_value || r.order,
+      scope: r.sys_scope?.display_value || r.sys_scope || 'global',
+      when: r.when?.display_value || r.when || '',
+      condition: r.filter_condition?.display_value || r.filter_condition?.value || '',
+    }))
+    .sort((a, b) => {
+      const aOrder = parseInt(String(a.order).replace(/,/g, ''), 10) || 0;
+      const bOrder = parseInt(String(b.order).replace(/,/g, ''), 10) || 0;
+      return aOrder - bOrder;
+    });
+}
+
+async function fetchFlows(app, sysId) {
+  const params = new URLSearchParams();
+  params.set('sysparm_query', `source_record=${sysId}`);
+  params.set('sysparm_limit', '20');
+  params.set('sysparm_fields', 'flow_catalog_model,name,execution_id,state,engine_major_version,sys_created_on,origins,calling_source');
+  params.set('sysparm_display_value', 'all');
+  try {
+    const records = await app.sdk.list('sys_flow_context', params);
+    return records.map(r => ({
+      flow: r.name?.display_value || r.name || r.flow_catalog_model?.display_value || r.flow_catalog_model?.value || '(deleted flow)',
+      executionId: r.execution_id?.display_value || r.execution_id,
+      state: r.state?.display_value || r.state,
+      version: r.engine_major_version?.display_value || r.engine_major_version,
+      started: r.sys_created_on?.display_value || r.sys_created_on,
+    }));
+  } catch {
+    return []; // Flow Designer might not be installed
+  }
+}
+
+export function formatInspectOutput(data) {
+  const lines = [];
+  lines.push('');
+  lines.push(`\u{1F4CB} ${data.table}  ${data.sys_id}`);
+  lines.push('');
+
+  // History section
+  lines.push('\u25B6 HISTORY');
+  lines.push('\u2500'.repeat(50));
+  if (data.history.length === 0) {
+    lines.push('  (no audit history found)');
+  } else {
+    for (const h of data.history.slice(0, 10)) {
+      lines.push(`  ${h.changedOn}  ${h.changedBy}  ${h.field}: ${h.oldValue || '(empty)'} \u2192 ${h.newValue}`);
+    }
+    if (data.history.length > 10) {
+      lines.push(`  ... and ${data.history.length - 10} more`);
+    }
+  }
+  lines.push('');
+
+  // Business rules section
+  lines.push('\u25B6 BUSINESS RULES');
+  lines.push('\u2500'.repeat(50));
+  if (data.businessRules.length === 0) {
+    lines.push('  (no active business rules on this table)');
+  } else {
+    // Group by execution phase: before → display → after → async
+    const phases = ['before', 'display', 'after', 'async'];
+    const grouped = {};
+    for (const br of data.businessRules) {
+      const phase = br.when?.toLowerCase() || '';
+      if (!grouped[phase]) grouped[phase] = [];
+      grouped[phase].push(br);
+    }
+    for (const phase of phases) {
+      const rules = grouped[phase]?.sort((a, b) => {
+        const aOrder = parseInt(String(a.order).replace(/,/g, ''), 10) || 0;
+        const bOrder = parseInt(String(b.order).replace(/,/g, ''), 10) || 0;
+        return aOrder - bOrder;
+      });
+      if (!rules || rules.length === 0) continue;
+      lines.push(`  ${phase.charAt(0).toUpperCase() + phase.slice(1)}:`);
+      for (const br of rules) {
+        lines.push(`    [${br.order}] ${br.name}${br.scope !== 'global' ? ` (${br.scope})` : ''}`);
+        if (br.condition) {
+          const cond = br.condition.length > 80 ? br.condition.substring(0, 77) + '...' : br.condition;
+          lines.push(`       Condition: ${cond}`);
+        }
+      }
+    }
+  }
+  lines.push('');
+
+  // Flows section
+  lines.push('\u25B6 RUNNING FLOWS');
+  lines.push('\u2500'.repeat(50));
+  if (data.flows.length === 0) {
+    lines.push('  (no running flows for this record)');
+  } else {
+    for (const f of data.flows) {
+      lines.push(`  Flow: ${f.flow}`);
+      lines.push(`  Status: ${f.state} | Version: ${f.version}`);
+      if (f.started) lines.push(`  Started: ${f.started}`);
+      lines.push('');
+    }
+  }
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+export async function inspectRecord(app, table, identifier) {
+  const sysId = await resolveIdentifier(app, table, identifier);
+  const [rawHistory, businessRules, flows] = await Promise.all([
+    fetchHistory(app, table, sysId),
+    fetchBusinessRules(app, table),
+    fetchFlows(app, sysId),
+  ]);
+  const history = await resolveHistoryDisplayValues(app, table, rawHistory);
+  return { table, sys_id: sysId, history, businessRules, flows };
+}