@jacebenson/jsn 1.0.7 → 2.0.2

package/src/commands/grouproles.js

@@ -0,0 +1,152 @@
+import { formatRecordForDisplay, getStringField } from '../helpers.js';
+
+export function groupRolesCmd(wrap) {
+  return {
+    command: 'grouproles [subcommand]',
+    aliases: ['grouprole', 'grole', 'gr'],
+    describe: 'Manage group roles',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List group roles',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query (e.g. "nameLIKEincident" or "active=true")' })
+            .option('columns', { alias: ['c', 'fields'], type: 'string', describe: 'Comma-separated columns (e.g. "number,short_description")' })
+            .option('limit', { alias: 'l', type: 'number', default: 20, describe: 'Max records' }),
+          handler: wrap(async (argv, app) => {
+            const columns = argv.columns ? argv.columns.split(',') : ['group.name', 'role.name'];
+            const params = new URLSearchParams();
+            params.set('sysparm_limit', String(argv.limit));
+            params.set('sysparm_display_value', 'all');
+            params.set('sysparm_fields', ['sys_id', ...columns].join(','));
+            if (argv.query) params.set('sysparm_query', argv.query);
+            const records = await app.sdk.list('sys_group_has_role', params);
+            app.ok({
+              table: 'sys_group_has_role',
+              count: records.length,
+              columns,
+              records: records.map(r => formatRecordForDisplay(r, columns)),
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} group role(s)` });
+          }),
+        })
+        .command({
+          command: 'add',
+          describe: 'Add a role to a group',
+          builder: (y) => y
+            .option('group', { alias: 'g', type: 'string', demandOption: true, describe: 'Group name or sys_id (required)' })
+            .option('role', { alias: 'r', type: 'string', demandOption: true, describe: 'Role name or sys_id (required)' }),
+          handler: wrap(async (argv, app) => {
+            const groupName = argv.group;
+            const roleName = argv.role;
+
+            // Resolve group sys_id
+            const isGroupSysID = groupName.length === 32 && /^[0-9a-fA-F]+$/.test(groupName);
+            const groupParams = new URLSearchParams();
+            groupParams.set('sysparm_query', isGroupSysID ? `sys_id=${groupName}` : `name=${groupName}`);
+            groupParams.set('sysparm_limit', '1');
+            groupParams.set('sysparm_fields', 'sys_id');
+            const groupRecords = await app.sdk.list('sys_user_group', groupParams);
+            if (groupRecords.length === 0) {
+              throw new Error(`Group not found: ${groupName}`);
+            }
+            const groupSysID = getStringField(groupRecords[0], 'sys_id');
+
+            // Resolve role sys_id
+            const isRoleSysID = roleName.length === 32 && /^[0-9a-fA-F]+$/.test(roleName);
+            const roleParams = new URLSearchParams();
+            roleParams.set('sysparm_query', isRoleSysID ? `sys_id=${roleName}` : `name=${roleName}`);
+            roleParams.set('sysparm_limit', '1');
+            roleParams.set('sysparm_fields', 'sys_id');
+            const roleRecords = await app.sdk.list('sys_user_role', roleParams);
+            if (roleRecords.length === 0) {
+              throw new Error(`Role not found: ${roleName}`);
+            }
+            const roleSysID = getStringField(roleRecords[0], 'sys_id');
+
+            // Check if role assignment already exists
+            const checkParams = new URLSearchParams();
+            checkParams.set('sysparm_query', `group=${groupSysID}^role=${roleSysID}`);
+            checkParams.set('sysparm_limit', '1');
+            checkParams.set('sysparm_fields', 'sys_id');
+            const existing = await app.sdk.list('sys_group_has_role', checkParams);
+            if (existing.length > 0) {
+              throw new Error(`Role ${roleName} is already assigned to group ${groupName}`);
+            }
+
+            // Create the role assignment
+            const record = await app.sdk.create('sys_group_has_role', {
+              group: groupSysID,
+              role: roleSysID,
+            });
+            app.ok(record, {
+              summary: `Added role ${roleName} to ${groupName}`,
+              breadcrumbs: [
+                { action: 'list', cmd: `jsn grouproles list --query "group.name=${groupName}"`, description: 'List group roles' },
+                { action: 'remove', cmd: `jsn grouproles remove --group "${groupName}" --role "${roleName}"`, description: 'Remove this role' },
+              ],
+            });
+          }),
+        })
+        .command({
+          command: 'remove',
+          describe: 'Remove a role from a group',
+          builder: (y) => y
+            .option('group', { alias: 'g', type: 'string', demandOption: true, describe: 'Group name or sys_id (required)' })
+            .option('role', { alias: 'r', type: 'string', demandOption: true, describe: 'Role name or sys_id (required)' }),
+          handler: wrap(async (argv, app) => {
+            const groupName = argv.group;
+            const roleName = argv.role;
+
+            // Resolve group sys_id
+            const isGroupSysID = groupName.length === 32 && /^[0-9a-fA-F]+$/.test(groupName);
+            const groupParams = new URLSearchParams();
+            groupParams.set('sysparm_query', isGroupSysID ? `sys_id=${groupName}` : `name=${groupName}`);
+            groupParams.set('sysparm_limit', '1');
+            groupParams.set('sysparm_fields', 'sys_id');
+            const groupRecords = await app.sdk.list('sys_user_group', groupParams);
+            if (groupRecords.length === 0) {
+              throw new Error(`Group not found: ${groupName}`);
+            }
+            const groupSysID = getStringField(groupRecords[0], 'sys_id');
+
+            // Resolve role sys_id
+            const isRoleSysID = roleName.length === 32 && /^[0-9a-fA-F]+$/.test(roleName);
+            const roleParams = new URLSearchParams();
+            roleParams.set('sysparm_query', isRoleSysID ? `sys_id=${roleName}` : `name=${roleName}`);
+            roleParams.set('sysparm_limit', '1');
+            roleParams.set('sysparm_fields', 'sys_id');
+            const roleRecords = await app.sdk.list('sys_user_role', roleParams);
+            if (roleRecords.length === 0) {
+              throw new Error(`Role not found: ${roleName}`);
+            }
+            const roleSysID = getStringField(roleRecords[0], 'sys_id');
+
+            // Find the role assignment record
+            const findParams = new URLSearchParams();
+            findParams.set('sysparm_query', `group=${groupSysID}^role=${roleSysID}`);
+            findParams.set('sysparm_limit', '1');
+            findParams.set('sysparm_fields', 'sys_id');
+            const assignmentRecords = await app.sdk.list('sys_group_has_role', findParams);
+            if (assignmentRecords.length === 0) {
+              throw new Error(`Role ${roleName} is not assigned to group ${groupName}`);
+            }
+            const assignmentSysID = getStringField(assignmentRecords[0], 'sys_id');
+
+            // Delete the role assignment
+            await app.sdk.delete('sys_group_has_role', assignmentSysID);
+            app.ok({ group: groupName, role: roleName }, {
+              summary: `Removed role ${roleName} from ${groupName}`,
+              breadcrumbs: [
+                { action: 'list', cmd: `jsn grouproles list --query "group.name=${groupName}"`, description: 'List group roles' },
+                { action: 'add', cmd: `jsn grouproles add --group "${groupName}" --role "${roleName}"`, description: 'Add role back to group' },
+              ],
+            });
+          }),
+        });
+    },
+    handler: () => {},
+  };
+}

package/src/commands/groups.js

@@ -0,0 +1,141 @@
+import { formatRecordForDisplay, getStringField, interactiveList } from '../helpers.js';
+
+export function groupsCmd(wrap) {
+  return {
+    command: 'groups [subcommand]',
+    aliases: ['group'],
+    describe: 'Manage ServiceNow groups',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List groups',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query (e.g. "nameLIKEincident" or "active=true")' })
+            .option('columns', { alias: ['c', 'fields'], type: 'string', describe: 'Comma-separated columns (e.g. "number,short_description")' })
+            .option('limit', { alias: 'l', type: 'number', default: 20, describe: 'Max records' }),
+          handler: wrap(async (argv, app) => {
+            const columns = argv.columns ? argv.columns.split(',') : ['name', 'manager', 'email'];
+            const query = argv.query || '';
+
+            const picked = await interactiveList({
+              app, table: 'sys_user_group', singular: 'group', columns, limit: argv.limit, query, labelField: 'name',
+              formatLabel: r => `${getStringField(r, 'name')} ${getStringField(r, 'manager') ? '→ ' + getStringField(r, 'manager') : ''}`,
+            });
+            if (picked) {
+              picked._context = { instance_url: app.getEffectiveInstance(), table: 'sys_user_group' };
+              return app.ok(picked, { summary: `Group: ${getStringField(picked, 'name')}` });
+            }
+
+            const params = new URLSearchParams();
+            params.set('sysparm_limit', String(argv.limit));
+            params.set('sysparm_display_value', 'all');
+            params.set('sysparm_fields', ['sys_id', ...columns].join(','));
+            if (argv.query) params.set('sysparm_query', argv.query);
+            const records = await app.sdk.list('sys_user_group', params);
+            app.ok({
+              table: 'sys_user_group',
+              count: records.length,
+              columns,
+              records: records.map(r => formatRecordForDisplay(r, columns)),
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} group(s)` });
+          }),
+        })
+        .command({
+          command: 'show <name>',
+          aliases: ['get'],
+          describe: 'Show a group by name or sys_id',
+          handler: wrap(async (argv, app) => {
+            const id = argv.name;
+            const isSysID = id.length === 32 && /^[0-9a-fA-F]+$/.test(id);
+            const params = new URLSearchParams();
+            params.set('sysparm_query', isSysID ? `sys_id=${id}` : `name=${id}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_display_value', 'all');
+            const records = await app.sdk.list('sys_user_group', params);
+            if (records.length === 0) {
+              throw new Error(`Group not found: ${id}`);
+            }
+            app.ok(records[0], { summary: `Group ${id}` });
+          }),
+        })
+        .command({
+          command: 'create',
+          describe: 'Create a new group',
+          builder: (y) => y
+            .option('name', { alias: 'n', type: 'string', describe: 'Group name' })
+            .option('manager', { type: 'string', describe: 'Manager name or sys_id' })
+            .option('data', { type: 'string', describe: 'JSON data for additional fields' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = {};
+            if (argv.data) {
+              Object.assign(recordData, JSON.parse(argv.data));
+            }
+            if (argv.name) recordData.name = argv.name;
+            if (argv.manager) recordData.manager = argv.manager;
+            if (!recordData.name) {
+              throw new Error('name is required (use --name or --data)');
+            }
+            const record = await app.sdk.create('sys_user_group', recordData);
+            app.ok(record, {
+              summary: `Created group ${getStringField(record, 'name')}`,
+              breadcrumbs: [
+                { action: 'view', cmd: `jsn groups show ${getStringField(record, 'name')}`, description: `View the new group` },
+              ],
+            });
+          }),
+        })
+        .command({
+          command: 'update <name>',
+          describe: 'Update a group by name or sys_id',
+          builder: (y) => y
+            .option('data', { type: 'string', demandOption: true, describe: 'JSON data to update' }),
+          handler: wrap(async (argv, app) => {
+            const id = argv.name;
+            const recordData = JSON.parse(argv.data);
+            const isSysID = id.length === 32 && /^[0-9a-fA-F]+$/.test(id);
+            const params = new URLSearchParams();
+            params.set('sysparm_query', isSysID ? `sys_id=${id}` : `name=${id}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_fields', 'sys_id');
+            const records = await app.sdk.list('sys_user_group', params);
+            if (records.length === 0) {
+              throw new Error(`Group not found: ${id}`);
+            }
+            const sysID = getStringField(records[0], 'sys_id');
+            const updated = await app.sdk.update('sys_user_group', sysID, recordData);
+            app.ok(updated, {
+              summary: `Updated group ${id}`,
+              breadcrumbs: [
+                { action: 'view', cmd: `jsn groups show ${id}`, description: `View the updated group` },
+              ],
+            });
+          }),
+        })
+        .command({
+          command: 'delete <name>',
+          describe: 'Delete a group by name or sys_id',
+          handler: wrap(async (argv, app) => {
+            const id = argv.name;
+            const isSysID = id.length === 32 && /^[0-9a-fA-F]+$/.test(id);
+            const params = new URLSearchParams();
+            params.set('sysparm_query', isSysID ? `sys_id=${id}` : `name=${id}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_fields', 'sys_id');
+            const records = await app.sdk.list('sys_user_group', params);
+            if (records.length === 0) {
+              throw new Error(`Group not found: ${id}`);
+            }
+            const sysID = getStringField(records[0], 'sys_id');
+            await app.sdk.delete('sys_user_group', sysID);
+            app.ok({ identifier: id, message: 'Group deleted' }, {
+              summary: `Deleted group ${id}`,
+            });
+          }),
+        });
+    },
+    handler: () => {},
+  };
+}

package/src/commands/incidents.js

@@ -0,0 +1,7 @@
+import { buildTicketCommands } from './_ticket.js';
+
+const incidentDefaultColumns = ['number', 'short_description', 'priority', 'state', 'assigned_to'];
+
+export function incidentsCmd(wrap) {
+  return buildTicketCommands('incident', 'incidents', 'inc', incidentDefaultColumns, {}, null, wrap);
+}

package/src/commands/profiles.js

@@ -0,0 +1,91 @@
+import { saveConfig } from '../config.js';
+
+export function profilesCmd(wrap) {
+  return {
+    command: 'profiles [subcommand]',
+    aliases: ['profile'],
+    describe: 'Manage configuration profiles',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          describe: 'List all profiles',
+          handler: wrap(async (_argv, app) => {
+            const profiles = [];
+            for (const [name, profile] of Object.entries(app.config.profiles || {})) {
+              const instance = profile.instance_url || '';
+              const isAuth = app.auth.isAuthenticatedFor(instance);
+              const isDefault = name === app.config.defaultProfile;
+              profiles.push({
+                name,
+                instance,
+                username: profile.username || '',
+                authenticated: isAuth,
+                default: isDefault,
+              });
+            }
+            app.ok({ profiles }, { summary: `${profiles.length} profile(s)` });
+          }),
+        })
+        .command({
+          command: 'use <name>',
+          describe: 'Set active profile',
+          handler: wrap(async (argv, app) => {
+            const name = argv.name;
+            if (!app.config.profiles[name]) {
+              throw new Error(`Profile not found: ${name}`);
+            }
+            app.config.defaultProfile = name;
+            app.config.activeProfile = name;
+            saveConfig(app.config);
+            app.ok({ active_profile: name }, { summary: `Active profile: ${name}` });
+          }),
+        })
+        .command({
+          command: 'show [name]',
+          describe: 'Show profile details',
+          handler: wrap(async (argv, app) => {
+            const name = argv.name || app.config.defaultProfile || Object.keys(app.config.profiles || {})[0];
+            if (!name || !app.config.profiles[name]) {
+              throw new Error('No profiles configured');
+            }
+            const profile = app.config.profiles[name];
+            app.ok({ name, ...profile }, { summary: `Profile: ${name}` });
+          }),
+        })
+        .command({
+          command: 'remove <name>',
+          describe: 'Remove a profile',
+          handler: wrap(async (argv, app) => {
+            const name = argv.name;
+            if (!app.config.profiles[name]) {
+              throw new Error(`Profile not found: ${name}`);
+            }
+            delete app.config.profiles[name];
+            if (app.config.defaultProfile === name) {
+              app.config.defaultProfile = '';
+            }
+            if (app.config.activeProfile === name) {
+              app.config.activeProfile = '';
+            }
+            saveConfig(app.config);
+            app.ok({ removed: name }, { summary: `Removed profile: ${name}` });
+          }),
+        })
+
+    },
+    handler: (argv) => {
+      // When no subcommand is given, show help
+      if (!argv._[1]) {
+        console.log('Manage your ServiceNow instance profiles.\n');
+        console.log('Usage: jsn profiles <list|show|use|remove> [options]\n');
+        console.log('Commands:');
+        console.log('  list           List all profiles');
+        console.log('  show [name]    Show profile details');
+        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.');
+      }
+    },
+  };
+}

package/src/commands/records.js

@@ -0,0 +1,171 @@
+import { formatRecordForDisplay, buildQuerySuffix, parseDataArg, getStringField, interactiveList } from '../helpers.js';
+
+const tableDefaultColumns = {
+  incident: ['number', 'short_description', 'priority', 'state', 'assigned_to'],
+  change_request: ['number', 'short_description', 'risk', 'state', 'assigned_to'],
+  change_task: ['number', 'short_description', 'state', 'assigned_to'],
+  problem: ['number', 'short_description', 'priority', 'state', 'assigned_to'],
+  sc_request: ['number', 'short_description', 'request_state', 'requested_for'],
+  sc_req_item: ['number', 'short_description', 'stage', 'assigned_to'],
+  sc_task: ['number', 'short_description', 'state', 'assigned_to'],
+  sys_user: ['user_name', 'name', 'email', 'active'],
+  sys_user_group: ['name', 'manager', 'email'],
+  cmdb_ci: ['name', 'operational_status', 'ip_address'],
+  cmdb_ci_server: ['name', 'operational_status', 'ip_address'],
+  kb_knowledge: ['number', 'short_description', 'workflow_state', 'author'],
+};
+
+function getDefaultColumns(table) {
+  return tableDefaultColumns[table] || ['sys_id'];
+}
+
+export function recordsCmd(wrap) {
+  return {
+    command: 'records <subcommand>',
+    describe: 'Query and manage records in any table (e.g. "records list --table incident --query priority=1")',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          describe: 'List records from a table',
+          builder: (y) => y
+            .option('table', { type: 'string', demandOption: true, describe: 'Table name' })
+            .option('sys-id', { type: 'string', describe: 'Record sys_id (filters to a single record)' })
+            .option('query', { type: 'string', describe: 'Encoded query (e.g. "nameLIKEincident" or "active=true")' })
+            .option('columns', { alias: ['c', 'fields'], type: 'string', describe: 'Comma-separated columns (e.g. "number,short_description")' })
+            .option('limit', { type: 'number', default: 20, describe: 'Max records' })
+            .option('offset', { type: 'number', default: 0, describe: 'Offset' }),
+          handler: wrap(async (argv, app) => {
+            const table = argv.table;
+            const columns = argv.columns ? argv.columns.split(',') : getDefaultColumns(table);
+            let query = argv.query || '';
+
+            // If --sys-id is provided, append it to the query
+            if (argv['sys-id']) {
+              if (query) query += '^';
+              query += `sys_id=${argv['sys-id']}`;
+            }
+
+            // Interactive picker (only when no --sys-id filter, otherwise go straight to results)
+            if (!argv['sys-id']) {
+              const picked = await interactiveList({
+                app, table, singular: 'record', columns, limit: argv.limit, query, labelField: 'sys_id',
+                formatLabel: r => {
+                  const cols = getDefaultColumns(table);
+                  return cols.map(c => `${c}: ${getStringField(r, c) || '-'}`).join(' | ');
+                },
+              });
+              if (picked) {
+                picked._context = { instance_url: app.getEffectiveInstance(), table };
+                return app.ok(picked, { summary: `Record from ${table}` });
+              }
+            }
+
+            // Text/table fallback (or sys-id direct lookup)
+            const params = new URLSearchParams();
+            params.set('sysparm_limit', argv['sys-id'] ? '1' : String(argv.limit));
+            params.set('sysparm_offset', String(argv.offset));
+            params.set('sysparm_display_value', 'all');
+            params.set('sysparm_fields', ['sys_id', ...columns].join(','));
+            if (query) params.set('sysparm_query', query);
+            const records = await app.sdk.list(table, params);
+            const displayRecords = records.map(r => formatRecordForDisplay(r, columns));
+            const breadcrumbs = [
+              { action: 'create', cmd: `jsn records create --table ${table} --data '{...}'`, description: 'Create a new record' },
+              { action: 'filter', cmd: `jsn records list --table ${table} --query "priority=1"`, description: 'Filter: priority 1 only' },
+              { action: 'columns', cmd: `jsn dev columns --table ${table}`, description: 'View available columns' },
+            ];
+            if (argv['sys-id']) {
+              breadcrumbs.unshift({
+                action: 'get',
+                cmd: `jsn records get --table ${table} --sys-id ${argv['sys-id']}`,
+                description: 'Get full record details',
+              });
+            }
+            if (records.length === argv.limit) {
+              breadcrumbs.push({
+                action: 'next',
+                cmd: `jsn records list --table ${table} --limit ${argv.limit} --offset ${argv.offset + argv.limit}${buildQuerySuffix(argv.query)}`,
+                description: `Next page`,
+              });
+            }
+            if (argv.offset > 0) {
+              breadcrumbs.push({
+                action: 'prev',
+                cmd: `jsn records list --table ${table} --limit ${argv.limit} --offset ${Math.max(0, argv.offset - argv.limit)}${buildQuerySuffix(argv.query)}`,
+                description: 'Previous page',
+              });
+            }
+            app.ok({
+              table,
+              count: records.length,
+              columns,
+              records: displayRecords,
+              pagination: { limit: argv.limit, offset: argv.offset },
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} record(s) from ${table}`, breadcrumbs });
+          }),
+        })
+        .command({
+          command: 'get',
+          describe: 'Get a single record by sys_id',
+          builder: (y) => y
+            .option('table', { type: 'string', demandOption: true, describe: 'Table name' })
+            .option('sys-id', { type: 'string', demandOption: true, describe: 'Record sys_id' })
+            .option('columns', { alias: ['c', 'fields'], type: 'string', describe: 'Comma-separated columns (e.g. "number,short_description")' }),
+          handler: wrap(async (argv, app) => {
+            const params = new URLSearchParams();
+            params.set('sysparm_query', `sys_id=${argv['sys-id']}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_display_value', 'true');
+            if (argv.columns) params.set('sysparm_fields', argv.columns);
+            const records = await app.sdk.list(argv.table, params);
+            if (records.length === 0) {
+              throw new Error(`Record not found: ${argv['sys-id']}`);
+            }
+            app.ok(records[0], { summary: `Record from ${argv.table}` });
+          }),
+        })
+        .command({
+          command: 'create',
+          describe: 'Create a new record',
+          builder: (y) => y
+            .option('table', { type: 'string', demandOption: true, describe: 'Table name' })
+            .option('data', { type: 'string', describe: 'JSON fields (e.g. \'{"state":"2"}\')' })
+            .option('data-file', { type: 'string', describe: 'Read JSON payload from file' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = parseDataArg(argv);
+            const record = await app.sdk.create(argv.table, recordData);
+            app.ok(record, { summary: `Created record in ${argv.table}` });
+          }),
+        })
+        .command({
+          command: 'update',
+          describe: 'Update an existing record',
+          builder: (y) => y
+            .option('table', { type: 'string', demandOption: true, describe: 'Table name' })
+            .option('sys-id', { type: 'string', demandOption: true, describe: 'Record sys_id' })
+            .option('data', { type: 'string', describe: 'JSON fields (e.g. \'{"state":"2"}\')' })
+            .option('data-file', { type: 'string', describe: 'Read JSON payload from file' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = parseDataArg(argv);
+            const record = await app.sdk.update(argv.table, argv['sys-id'], recordData);
+            app.ok(record, { summary: `Updated record in ${argv.table}` });
+          }),
+        })
+        .command({
+          command: 'delete',
+          describe: 'Delete a record',
+          builder: (y) => y
+            .option('table', { type: 'string', demandOption: true, describe: 'Table name' })
+            .option('sys-id', { type: 'string', demandOption: true, describe: 'Record sys_id' }),
+          handler: wrap(async (argv, app) => {
+            await app.sdk.delete(argv.table, argv['sys-id']);
+            app.ok({ message: 'Record deleted', table: argv.table, sys_id: argv['sys-id'] }, { summary: `Deleted record from ${argv.table}` });
+          }),
+        })
+
+    },
+    handler: () => {},
+  };
+}

package/src/commands/requests.js

@@ -0,0 +1,59 @@
+import { buildTicketCommands } from './_ticket.js';
+import { getStringField } from '../helpers.js';
+
+const requestDefaultColumns = ['number', 'short_description', 'stage', 'assigned_to'];
+
+export function requestsCmd(wrap) {
+  // Get the base command definition from the shared ticket builder
+  const baseCmd = buildTicketCommands('sc_req_item', 'requests', 'req', requestDefaultColumns, {}, null, wrap);
+
+  // Override the builder to inject our enriched show handler.
+  // yargs allows re-registration — the last .command() call wins the slot.
+  const originalBuilder = baseCmd.builder;
+  baseCmd.builder = (yargs) => {
+    const y = originalBuilder(yargs);
+    return y.command({
+      command: 'show <number>',
+      aliases: ['get'],
+      describe: 'Show a specific request with attachments and catalog variables',
+      handler: wrap(enrichedShowHandler),
+    });
+  };
+
+  return baseCmd;
+}
+
+async function enrichedShowHandler(argv, app) {
+  const number = argv.number;
+  const params = new URLSearchParams();
+  params.set('sysparm_query', `number=${number}`);
+  params.set('sysparm_display_value', 'all');
+  params.set('sysparm_limit', '1');
+  const records = await app.sdk.list('sc_req_item', params);
+  if (records.length === 0) {
+    throw new Error(`Request not found: ${number}`);
+  }
+  const record = records[0];
+  const sysID = getStringField(record, 'sys_id');
+
+  // Fetch attachments and catalog variables in parallel
+  const [attachments, variables] = await Promise.all([
+    app.sdk.fetchAttachments('sc_req_item', sysID).catch(() => []),
+    app.sdk.fetchCatalogVariables(sysID).catch(() => []),
+  ]);
+
+  record._attachments = attachments;
+  record._variables = variables;
+  record._context = {
+    instance_url: app.getEffectiveInstance(),
+    table: 'sc_req_item',
+  };
+
+  app.ok(record, {
+    summary: `Request ${number}`,
+    breadcrumbs: [
+      { action: 'update', cmd: `jsn req update ${number} --data '{...}'`, description: 'Update this request' },
+      { action: 'list', cmd: `jsn req list`, description: 'Back to all requests' },
+    ],
+  });
+}

package/src/commands/setup.js

@@ -0,0 +1,39 @@
+import readline from 'node:readline';
+import { getEffectiveInstance, normalizeInstanceURL, saveConfig, setProfile } from '../config.js';
+
+export function setupCmd(wrap) {
+  return {
+    command: 'setup',
+    describe: 'Interactive first-time setup',
+    handler: wrap(async (_argv, app) => {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+
+      console.log('Welcome to JSN - ServiceNow CLI');
+      console.log();
+
+      let instance = getEffectiveInstance(app.config);
+      if (!instance) {
+        instance = await ask('ServiceNow instance URL (e.g., dev12345.service-now.com): ');
+        instance = normalizeInstanceURL(instance);
+      }
+      console.log(`Instance: ${instance}`);
+
+      const profileName = await ask('Profile name (default): ') || 'default';
+      await setProfile(app.config, profileName, { instance_url: instance });
+      // Set as active profile so subsequent commands know which instance to use
+      app.config.activeProfile = profileName;
+      app.config.defaultProfile = profileName;
+      saveConfig(app.config);
+
+      const loginNow = await ask('Login now? [Y/n]: ');
+      if (!loginNow || loginNow.toLowerCase() !== 'n') {
+        await app.auth.login(instance);
+        console.log('Login successful!');
+      }
+
+      rl.close();
+      app.ok({ setup: true, instance, profile: profileName }, { summary: 'Setup complete' });
+    }),
+  };
+}