@jacebenson/jsn 0.0.3

package/src/commands/dev/scopes.js

@@ -0,0 +1,96 @@
+import { formatRecordForDisplay, getStringField } from '../../helpers.js';
+
+export function scopesCmd(wrap) {
+  return {
+    command: 'scopes [subcommand]',
+    aliases: ['scope', 'sc'],
+    describe: 'Manage application scopes',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List application scopes',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query string' })
+            .option('columns', { alias: 'c', type: 'string', describe: 'Comma-separated columns' })
+            .option('limit', { alias: 'l', type: 'number', default: 20, describe: 'Max records' }),
+          handler: wrap(async (argv, app) => {
+            const columns = argv.columns ? argv.columns.split(',') : ['name', 'scope', 'short_description', 'active'];
+            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(','));
+            const q = argv.query ? argv.query + '^ORDERBYDESCsys_updated_on' : 'ORDERBYDESCsys_updated_on';
+            params.set('sysparm_query', q);
+            const records = await app.sdk.list('sys_scope', params);
+            app.ok({
+              table: 'sys_scope',
+              count: records.length,
+              columns,
+              records: records.map(r => formatRecordForDisplay(r, columns)),
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} scope(s)` });
+          }),
+        })
+        .command({
+          command: 'show <scope>',
+          aliases: ['get'],
+          describe: 'Show a scope',
+          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) {
+              throw new Error(`Scope not found: ${argv.scope}`);
+            }
+            app.ok(records[0], { summary: `Scope ${argv.scope}` });
+          }),
+        })
+        .command({
+          command: 'set <scope>',
+          describe: 'Set the current application scope',
+          handler: wrap(async (argv, app) => {
+            const params = new URLSearchParams();
+            params.set('sysparm_query', `scope=${argv.scope}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_fields', 'sys_id,scope');
+            const records = await app.sdk.list('sys_scope', params);
+            if (records.length === 0) {
+              throw new Error(`Scope not found: ${argv.scope}`);
+            }
+            const scopeSysID = getStringField(records[0], 'sys_id');
+            // Update user preference
+            const user = await app.sdk.list('sys_user', new URLSearchParams({
+              sysparm_query: 'user_name=javascript:gs.getUserName()',
+              sysparm_limit: '1',
+              sysparm_fields: 'sys_id',
+            }));
+            if (user.length === 0) {
+              throw new Error('Could not determine current user');
+            }
+            const userSysID = getStringField(user[0], 'sys_id');
+            const prefParams = new URLSearchParams();
+            prefParams.set('sysparm_query', `user=${userSysID}^name=apps.current_app`);
+            prefParams.set('sysparm_limit', '1');
+            const prefs = await app.sdk.list('sys_user_preference', prefParams);
+            if (prefs.length > 0) {
+              await app.sdk.update('sys_user_preference', getStringField(prefs[0], 'sys_id'), { value: scopeSysID });
+            } else {
+              await app.sdk.create('sys_user_preference', {
+                user: userSysID,
+                name: 'apps.current_app',
+                value: scopeSysID,
+                type: 'string',
+              });
+            }
+            app.ok({ scope: argv.scope, sys_id: scopeSysID }, { summary: `Current scope: ${argv.scope}` });
+          }),
+        })
+
+    },
+    handler: () => {},
+  };
+}

package/src/commands/dev/updatesets.js

@@ -0,0 +1,97 @@
+import { formatRecordForDisplay, getStringField } from '../../helpers.js';
+
+export function updateSetsCmd(wrap) {
+  return {
+    command: 'updatesets [subcommand]',
+    aliases: ['updateset', 'us'],
+    describe: 'Manage update sets',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List update sets',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query string' })
+            .option('columns', { alias: 'c', type: 'string', describe: 'Comma-separated columns' })
+            .option('limit', { alias: 'l', type: 'number', default: 20, describe: 'Max records' }),
+          handler: wrap(async (argv, app) => {
+            const columns = argv.columns ? argv.columns.split(',') : ['name', 'state', 'application'];
+            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(','));
+            const q = argv.query ? argv.query + '^ORDERBYDESCsys_updated_on' : 'ORDERBYDESCsys_updated_on';
+            params.set('sysparm_query', q);
+            const records = await app.sdk.list('sys_update_set', params);
+            app.ok({
+              table: 'sys_update_set',
+              count: records.length,
+              columns,
+              records: records.map(r => formatRecordForDisplay(r, columns)),
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} update set(s)` });
+          }),
+        })
+        .command({
+          command: 'show <name>',
+          aliases: ['get'],
+          describe: 'Show an update set',
+          handler: wrap(async (argv, app) => {
+            const params = new URLSearchParams();
+            params.set('sysparm_query', `name=${argv.name}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_display_value', 'all');
+            const records = await app.sdk.list('sys_update_set', params);
+            if (records.length === 0) {
+              throw new Error(`Update set not found: ${argv.name}`);
+            }
+            app.ok(records[0], { summary: `Update set ${argv.name}` });
+          }),
+        })
+        .command({
+          command: 'set <name>',
+          describe: 'Set the current update set',
+          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');
+            // Update user preference
+            const user = await app.sdk.list('sys_user', new URLSearchParams({
+              sysparm_query: 'user_name=javascript:gs.getUserName()',
+              sysparm_limit: '1',
+              sysparm_fields: 'sys_id',
+            }));
+            if (user.length === 0) {
+              throw new Error('Could not determine current user');
+            }
+            const userSysID = getStringField(user[0], 'sys_id');
+            // Find or create preference
+            const prefParams = new URLSearchParams();
+            prefParams.set('sysparm_query', `user=${userSysID}^name=sys_update_set`);
+            prefParams.set('sysparm_limit', '1');
+            const prefs = await app.sdk.list('sys_user_preference', prefParams);
+            if (prefs.length > 0) {
+              await app.sdk.update('sys_user_preference', getStringField(prefs[0], 'sys_id'), { value: sysID });
+            } else {
+              await app.sdk.create('sys_user_preference', {
+                user: userSysID,
+                name: 'sys_update_set',
+                value: sysID,
+                type: 'string',
+              });
+            }
+            app.ok({ update_set: argv.name, sys_id: sysID }, { summary: `Current update set: ${argv.name}` });
+          }),
+        })
+
+    },
+    handler: () => {},
+  };
+}

package/src/commands/dev.js

@@ -0,0 +1,53 @@
+// Parent dev command
+
+import {
+  actionsCmd, includesCmd, rulesCmd,
+  clientScriptsCmd, uiActionsCmd, uiPoliciesCmd,
+  tablesCmd, columnsCmd, importCmd,
+  spPagesCmd, spWidgetsCmd, uiPagesCmd, appMenuCmd, scRAPICmd,
+  aclsCmd, rolesCmd, propertiesCmd,
+} from './dev/_simple.js';
+import { flowsCmd } from './dev/flows.js';
+import { formsCmd } from './dev/forms.js';
+import { listsCmd } from './dev/lists.js';
+import { updateSetsCmd } from './dev/updatesets.js';
+import { scopesCmd } from './dev/scopes.js';
+import { evalCmd } from './dev/eval.js';
+import { restCmd } from './dev/rest.js';
+import { logsCmd } from './dev/logs.js';
+
+export function devCmd(wrap) {
+  return {
+    command: 'dev [subcommand]',
+    describe: 'Manage ServiceNow development artifacts',
+    builder: (yargs) => {
+      return yargs
+        .command(flowsCmd(wrap))
+        .command(actionsCmd(wrap))
+        .command(includesCmd(wrap))
+        .command(rulesCmd(wrap))
+        .command(clientScriptsCmd(wrap))
+        .command(uiActionsCmd(wrap))
+        .command(uiPoliciesCmd(wrap))
+        .command(tablesCmd(wrap))
+        .command(columnsCmd(wrap))
+        .command(formsCmd(wrap))
+        .command(listsCmd(wrap))
+        .command(importCmd(wrap))
+        .command(spPagesCmd(wrap))
+        .command(spWidgetsCmd(wrap))
+        .command(uiPagesCmd(wrap))
+        .command(appMenuCmd(wrap))
+        .command(scRAPICmd(wrap))
+        .command(aclsCmd(wrap))
+        .command(rolesCmd(wrap))
+        .command(updateSetsCmd(wrap))
+        .command(scopesCmd(wrap))
+        .command(propertiesCmd(wrap))
+        .command(logsCmd(wrap))
+        .command(evalCmd(wrap))
+        .command(restCmd(wrap));
+    },
+    handler: () => {},
+  };
+}

package/src/commands/groupmembers.js

@@ -0,0 +1,39 @@
+import { formatRecordForDisplay } from '../helpers.js';
+
+export function groupMembersCmd(wrap) {
+  return {
+    command: 'groupmembers [subcommand]',
+    aliases: ['groupmember', 'gmember', 'gm'],
+    describe: 'Manage group memberships',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List group members',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query string' })
+            .option('columns', { alias: 'c', type: 'string', describe: 'Comma-separated columns' })
+            .option('limit', { alias: 'l', type: 'number', default: 20, describe: 'Max records' }),
+          handler: wrap(async (argv, app) => {
+            const columns = argv.columns ? argv.columns.split(',') : ['user.name', 'group.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_grmember', params);
+            app.ok({
+              table: 'sys_user_grmember',
+              count: records.length,
+              columns,
+              records: records.map(r => formatRecordForDisplay(r, columns)),
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} group member(s)` });
+          }),
+        })
+
+    },
+    handler: () => {},
+  };
+}

package/src/commands/grouproles.js

@@ -0,0 +1,39 @@
+import { formatRecordForDisplay } 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 string' })
+            .option('columns', { alias: 'c', type: 'string', describe: 'Comma-separated columns' })
+            .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)` });
+          }),
+        })
+
+    },
+    handler: () => {},
+  };
+}

package/src/commands/groups.js

@@ -0,0 +1,57 @@
+import { formatRecordForDisplay } from '../helpers.js';
+
+export function groupsCmd(wrap) {
+  return {
+    command: 'groups [subcommand]',
+    aliases: ['group'],
+    describe: 'Search and display groups',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List groups',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query string' })
+            .option('columns', { alias: 'c', type: 'string', describe: 'Comma-separated columns' })
+            .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 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}` });
+          }),
+        })
+
+    },
+    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,79 @@
+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: () => {},
+  };
+}

package/src/commands/records.js

@@ -0,0 +1,137 @@
+import { formatRecordForDisplay, buildQuerySuffix } 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',
+    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('query', { type: 'string', describe: 'Encoded query string' })
+            .option('columns', { alias: 'c', type: 'string', describe: 'Comma-separated columns' })
+            .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);
+            const params = new URLSearchParams();
+            params.set('sysparm_limit', 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 (argv.query) params.set('sysparm_query', argv.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 (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', { type: 'string', describe: 'Comma-separated columns' }),
+          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', demandOption: true, describe: 'JSON data' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = JSON.parse(argv.data);
+            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', demandOption: true, describe: 'JSON data' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = JSON.parse(argv.data);
+            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,7 @@
+import { buildTicketCommands } from './_ticket.js';
+
+const requestDefaultColumns = ['number', 'short_description', 'stage', 'assigned_to'];
+
+export function requestsCmd(wrap) {
+  return buildTicketCommands('sc_req_item', 'requests', 'req', requestDefaultColumns, {}, null, wrap);
+}

package/src/commands/setup.js

@@ -0,0 +1,35 @@
+import readline from 'node:readline';
+import { getEffectiveInstance, normalizeInstanceURL, 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 });
+
+      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' });
+    }),
+  };
+}

package/src/commands/tasks.js

@@ -0,0 +1,7 @@
+import { buildTicketCommands } from './_ticket.js';
+
+const taskDefaultColumns = ['number', 'short_description', 'state', 'assigned_to'];
+
+export function tasksCmd(wrap) {
+  return buildTicketCommands('sc_task', 'tasks', 'task', taskDefaultColumns, {}, null, wrap);
+}