@jacebenson/jsn 4.2.2 → 4.2.4

package/README.md

@@ -53,6 +53,12 @@ jsn incidents create --description "Server down" --priority 1
 # Admin tasks
 jsn flows list                                # Interactive picker with pagination
 jsn flows show "Assign Task"                  # Full flow detail
+jsn flows executions                          # All states, newest first
+jsn flows executions --active                  # Only waiting/running/queued
+jsn flows executions --since "2026-08-25 00:00:00" --until "2026-08-26 00:00:00"
+jsn flows executions --summary                 # Server totals + sampled duration metrics by flow
+jsn flows executions --limit 100               # Inspect more rows from the matching population
+jsn flows executions --record <sys_id>        # Executions for one source record
 jsn rules list --query "collection=incident"
 jsn updatesets set "My Feature"
 
@@ -78,6 +84,20 @@ jsn snippets run open-inc
 jsn logs follow --level error --tail 10
 ```
 
+### Flow execution fields
+
+`jsn flows executions` reads `sys_flow_context` and returns both the raw row and a normalized `execution` object. JSN discovers the runtime columns from `sys_dictionary` first, then uses these mappings:
+
+- `started`: `started`, `start_time`, `started_at`, then `sys_created_on`
+- `ended`: `ended`, `end_time`, `ended_at`, then `completed_on`
+- `duration_seconds`: stored `duration`, `run_time`, or `execution_duration`, otherwise `ended - started`
+- `waiting_age_seconds`: current time minus `started` while the status is waiting, queued, paused, or pending
+- `execution_age_seconds`: current time minus `started` while the status is running, executing, or processing
+- `status`: `state`, then `status`, then `execution_state`
+- `error`: `error`, `error_message`, `exception`, then `message`
+
+The timestamp fields are instance-dependent. `sys_created_on` is a fallback for when the context row was created, not a claim that it is the true runtime start time.
+
 ## Commands
 
 Run `jsn` for the full grouped list. Commands are organized by ServiceNow domain:

package/package.json

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

package/src/auth.js

@@ -271,6 +271,25 @@ function askHidden(promptText) {
   return passwordPrompt({ message: promptText });
 }
 
+/**
+ * Extract the browser session token and cookies from pasted DevTools headers
+ * or a "Copy as cURL" command. Only these two values are retained.
+ */
+export function parseBrowserSessionInput(input) {
+  const text = String(input || '');
+  const tokenMatch = text.match(/(?:x-usertoken|x-user-token)\s*:\s*([^\s'";,]+)/i);
+  const cookieArgMatch = text.match(/(?:^|\s)(?:-b|--cookie)\s+(['"])(.*?)\1/s);
+  const quotedCookieMatch = text.match(/cookie\s*:\s*(['"])(.*?)\1/i);
+  const plainCookieMatch = text.match(/cookie\s*:\s*([^\r\n]+)/i);
+  const token = tokenMatch?.[1]?.trim() || '';
+  const cookies = (cookieArgMatch?.[2] || quotedCookieMatch?.[2] || plainCookieMatch?.[1] || '')
+    .trim()
+    .replace(/['"`]\s*(?:\\\s*)?$/, '');
+  if (!token) throw errAuth('No X-UserToken header found');
+  if (!cookies) throw errAuth('No Cookie header found. Paste the complete request headers or cURL command.');
+  return { auth_method: 'gck', access_token: token, cookies, auth_source: 'gck' };
+}
+
 export class AuthManager {
   /**
    * @param {object} identity — the resolved-identity provider. Production
@@ -366,6 +385,12 @@ export class AuthManager {
     if (getBasicAuthFromEnv(instance)) return true;
     const creds = loadCredentials(instance, this._activeUsername());
     if (!creds) return false;
+    if (creds.auth_method === 'basic') {
+      return Boolean(creds.username && creds.password);
+    }
+    if (creds.auth_method === 'gck') {
+      return Boolean(creds.access_token && creds.cookies);
+    }
     if (creds.expires_at && Date.now() >= creds.expires_at * 1000) return false;
     return !!creds.access_token;
   }
@@ -384,11 +409,11 @@ export class AuthManager {
     return this.getCredentialsFor(instance);
   }
 
-  getCredentialsFor(instance) {
+  getCredentialsFor(instance, username = this._activeUsername()) {
     // Check basic auth from env vars first
     const basicCreds = getBasicAuthFromEnv(instance);
     if (basicCreds) return basicCreds;
-    const creds = loadCredentials(instance, this._activeUsername());
+    const creds = loadCredentials(instance, username);
     if (!creds) {
       throw errAuth(`Not authenticated for ${instance}`);
     }
@@ -483,17 +508,19 @@ export class AuthManager {
    * Reads SN_USERNAME/SN_PASSWORD (or SN_<INSTANCE>_USERNAME/SN_<INSTANCE>_PASSWORD).
    * Stores the basic auth credentials so they persist across sessions.
    */
-  async loginWithPassword(instanceURL) {
+  async loginWithPassword(instanceURL, username = this._activeUsername()) {
     instanceURL = normalizeInstanceURL(instanceURL);
-    const creds = getBasicAuthFromEnv(instanceURL);
-    if (!creds) {
+    const envCreds = getBasicAuthFromEnv(instanceURL);
+    const storedCreds = loadCredentials(instanceURL, username);
+    const creds = envCreds || storedCreds;
+    if (!creds || creds.auth_method !== 'basic' || !creds.username || !creds.password) {
       throw errAuth(
-        `No basic auth credentials found in environment.\n\n` +
+        `No basic auth credentials found in environment or stored profile.\n\n` +
         `Set the following environment variables:\n` +
         `  SN_USERNAME=admin           (or SN_${envVarName(instanceURL)}_USERNAME)\n` +
         `  SN_PASSWORD=<password>      (or SN_${envVarName(instanceURL)}_PASSWORD)\n\n` +
         `Then run:\n` +
-        `  jsn auth login --password ${instanceURL}`
+        `  jsn auth login --basic ${instanceURL}`
       );
     }
     saveCredentials(instanceURL, creds, creds.username);
@@ -505,6 +532,13 @@ export class AuthManager {
    * Complete login using an authorization code obtained from a prior buildAuthURL() call.
    * The PKCE state must have been saved by an earlier buildAuthURL() call.
    */
+  async loginWithGck(instanceURL, input, username = this._activeUsername()) {
+    instanceURL = normalizeInstanceURL(instanceURL);
+    const creds = parseBrowserSessionInput(input);
+    saveCredentials(instanceURL, { ...creds, username: username || undefined }, username || undefined);
+    return { ...creds, username: username || undefined };
+  }
+
   async loginWithCode(instanceURL, code) {
     instanceURL = normalizeInstanceURL(instanceURL);
     const clientID = getOAuthClientID();

package/src/cli.js

@@ -29,6 +29,9 @@ import { groupsCmd } from './commands/groups.js';
 import { groupMembersCmd } from './commands/groupmembers.js';
 import { groupRolesCmd } from './commands/grouproles.js';
 import { ticketsCmd } from './commands/tickets.js';
+import { transactionsCmd } from './commands/transactions.js';
+import { instanceCmd } from './commands/instance.js';
+import { platformCmd } from './commands/platform.js';
 import { codesearchCmd } from './commands/codesearch.js';
 import { versionCmd } from './commands/version.js';
 import { devCmd } from './commands/dev.js';
@@ -354,6 +357,9 @@ export function buildCLI() {
     // DATA
     .command(cmdbCmd(wrap))
     .command(recordsCmd(wrap))
+    .command(transactionsCmd(wrap))
+    .command(instanceCmd(wrap))
+    .command(platformCmd(wrap))
     .command(snippetsCmd(wrap))
     .command(ticketsCmd(wrap))
     .command(codesearchCmd(wrap))

package/src/commands/auth.js

@@ -82,6 +82,25 @@ export function resolveInstanceArg(arg, cfg) {
   return normalizeInstanceURL(`${trimmed}.service-now.com`);
 }
 
+/**
+ * Select the login method. Explicit Basic Auth wins; otherwise reuse the
+ * method recorded on an existing profile. New instances remain OAuth by
+ * default.
+ */
+export function shouldUseBasicAuth(argv = {}, cfg = {}, instanceURL = '') {
+  if (argv.basic || argv.password) return true;
+  return Object.values(cfg.profiles || {}).some(profile =>
+    profile.instance_url === instanceURL && profile.auth_method === 'basic'
+  );
+}
+
+export function shouldUseGckAuth(argv = {}, cfg = {}, instanceURL = '') {
+  if (argv.gck || argv.headers) return true;
+  return Object.values(cfg.profiles || {}).some(profile =>
+    profile.instance_url === instanceURL && profile.auth_method === 'gck'
+  );
+}
+
 /**
  * Pick a profile by name — interactive search picker when ambiguous,
  * auto-selects when there's exactly one, throws when none configured.
@@ -111,9 +130,50 @@ export async function pickProfile(app, message) {
  * always asks otherwise.
  */
 export function resolveWizardInstance(app, argv = {}) {
-  // app.getEffectiveInstance() is the session-backed read (production App);
-  // the _overrideInstance fallback keeps hand-rolled test fakes honest.
-  return process.env.SERVICENOW_INSTANCE_URL || app.getEffectiveInstance?.() || app._overrideInstance || argv.instance || '';
+  // Only explicit inputs may pre-fill the wizard. The active/default profile
+  // belongs to the existing connection and must not silently become the new
+  // instance when setup is adding a profile.
+  return process.env.SERVICENOW_INSTANCE_URL || app._overrideInstance || argv.instance || '';
+}
+
+export async function readBrowserSessionInput() {
+  const stdin = process.stdin;
+  console.log('Paste the complete cURL command, then press Ctrl+D:');
+  if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
+    const chunks = [];
+    for await (const chunk of stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString();
+  }
+
+  return new Promise((resolve, reject) => {
+    let pasted = '';
+    const finish = () => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener('data', onData);
+      stdin.removeListener('error', onError);
+      process.stdout.write('\n');
+    };
+    const onError = (err) => { finish(); reject(err); };
+    const onData = (chunk) => {
+      const text = chunk.toString();
+      const eof = text.indexOf('\x04');
+      if (eof !== -1) {
+        pasted += text.slice(0, eof);
+        finish();
+        resolve(pasted);
+      } else if (text.includes('\x03')) {
+        finish();
+        reject(new Error('Browser session input cancelled'));
+      } else {
+        pasted += text;
+      }
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on('data', onData);
+    stdin.on('error', onError);
+  });
 }
 
 /**
@@ -126,7 +186,7 @@ export function resolveWizardInstance(app, argv = {}) {
  */
 export async function loginWizard(app, argv = {}) {
   const readline = (await import('node:readline')).default;
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let 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');
@@ -161,8 +221,9 @@ export async function loginWizard(app, argv = {}) {
     profile.skip_confirmations = true;
   }
 
-  const authMethod = await ask('Authentication method (OAuth/Basic) [OAuth]: ');
-  const useBasic = authMethod.toLowerCase().startsWith('b');
+  const authMethod = await ask('Authentication method (OAuth/Basic/Browser session) [OAuth]: ');
+  const useGck = authMethod.toLowerCase().startsWith('g') || authMethod.toLowerCase().startsWith('browser');
+  const useBasic = !useGck && authMethod.toLowerCase().startsWith('b');
 
   let loggedIn = false;
   if (useBasic) {
@@ -179,6 +240,12 @@ export async function loginWizard(app, argv = {}) {
     }
     profile.username = username;
     profile.auth_method = 'basic';
+  } else if (useGck) {
+    rl.close();
+    const input = await readBrowserSessionInput();
+    await app.auth.loginWithGck(instance, input);
+    profile.auth_method = 'gck';
+    loggedIn = true;
   } else {
     profile.auth_method = 'oauth';
   }
@@ -192,6 +259,11 @@ export async function loginWizard(app, argv = {}) {
   // so a piped/scripted call never blocks on prompts.
   const { canPrompt } = await import('../helpers.js');
   if (canPrompt()) {
+    // @inquirer/prompts owns stdin while these confirmations run. Close the
+    // older readline interface before handing stdin to Inquirer. This matters
+    // on Windows Git Bash: leaving both readers attached can make the later
+    // OAuth question see EOF and let Node exit instead of waiting for input.
+    rl.close();
     const { confirm } = await import('@inquirer/prompts');
     profile.read_only = await confirm({ message: 'Read-only profile (blocks mutation commands)?', default: profile.read_only || false });
     profile.skip_confirmations = await confirm({ message: 'Skip confirmations (deletes run without prompting)?', default: profile.skip_confirmations || false });
@@ -201,7 +273,10 @@ export async function loginWizard(app, argv = {}) {
 
   await saveConfig(app.config);
 
-  if (!useBasic) {
+  if (!useBasic && !useGck) {
+    // Recreate readline after Inquirer has released stdin. Do not reuse the
+    // interface that was open before the confirmation prompts.
+    rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const loginNow = await ask('Login now? [Y/n]: ');
     rl.close();
     if (!loginNow || loginNow.toLowerCase() !== 'n') {
@@ -426,7 +501,7 @@ export async function removeProfile(app, name) {
 export function authCmd(wrap) {
   return {
     command: 'auth [subcommand]',
-    describe: 'Manage authentication (OAuth or basic auth via env vars)',
+    describe: 'Manage authentication (OAuth or Basic Auth)',
     builder: (yargs) => {
       return yargs
         .command({
@@ -437,8 +512,9 @@ export function authCmd(wrap) {
               describe: 'Authorization code from browser (bypasses interactive prompt)',
               type: 'string',
             })
-            .option('password', {
-              describe: 'Authenticate with basic auth via env vars (SN_USERNAME/SN_PASSWORD)',
+            .option('basic', {
+              alias: 'password',
+              describe: 'Authenticate with Basic Auth via env vars (SN_USERNAME/SN_PASSWORD)',
               type: 'boolean',
             })
             .option('print-url', {
@@ -497,15 +573,20 @@ export function authCmd(wrap) {
 Examples:
   jsn auth login https://dev12345.service-now.com
   jsn auth login dev373698
-  jsn auth login --password https://dev328604.service-now.com
+  jsn auth login --basic https://dev328604.service-now.com
 
 Find your instance URL in your browser's address bar when logged into ServiceNow.`);
               }
             }
 
-            // --password: authenticate with basic auth from env vars
-            if (argv.password) {
-              await app.auth.loginWithPassword(instanceURL);
+            const targetProfile = Object.values(app.config.profiles || {})
+              .find(profile => profile.instance_url === instanceURL);
+            const targetUsername = targetProfile?.username || '';
+            const useBasic = shouldUseBasicAuth(argv, app.config, instanceURL);
+            // --basic (with --password as a compatibility alias): authenticate
+            // with basic auth from env vars and persist it for this profile.
+            if (useBasic) {
+              await app.auth.loginWithPassword(instanceURL, targetUsername || undefined);
             }
             // --print-url with --wait-file: print URL and wait for code file
             else if (argv.printUrl && argv.waitFile) {
@@ -528,9 +609,12 @@ Find your instance URL in your browser's address bar when logged into ServiceNow
             // Verify auth by fetching current user
             let username = '';
             try {
-              if (!app.sdk) {
+              if (!app.sdk || targetUsername) {
                 const { SDKClient } = await import('../sdk.js');
-                app.sdk = new SDKClient(instanceURL, app.auth);
+                const authProvider = targetUsername
+                  ? { getCredentials: () => app.auth.getCredentialsFor(instanceURL, targetUsername) }
+                  : app.auth;
+                app.sdk = new SDKClient(instanceURL, authProvider);
               }
               const user = await app.sdk.getCurrentUser();
               username = user?.user_name || user?.name || '';
@@ -560,7 +644,7 @@ Find your instance URL in your browser's address bar when logged into ServiceNow
             app.config.profiles[profileName] = {
               ...(app.config.profiles[profileName] || {}),
               instance_url: instanceURL,
-              auth_method: argv.password ? 'basic' : 'oauth',
+              auth_method: useBasic ? 'basic' : 'oauth',
               username: username || undefined,
               read_only: argv['read-only'] || undefined,
               skip_confirmations: argv['skip-confirmations'] || undefined,
@@ -571,7 +655,7 @@ Find your instance URL in your browser's address bar when logged into ServiceNow
             // so they're keyed by <user>@<instance> for per-user isolation.
             // The legacy bare-instance key is cleaned up behind the
             // AuthManager seam (credential-store internals don't leak here).
-            if (!argv.password && username) {
+            if (!useBasic && username) {
               app.auth.migrateLegacyCredential(instanceURL, username);
             }
 

package/src/commands/dev/flows.js

@@ -1,4 +1,5 @@
 import { formatRecordForDisplay, getStringField, interactiveList } from '../../helpers.js';
+import { discoverFlowContextFields, normalizeFlowContext, summarizeFlowContexts, formatFlowContextSummary, aggregateFlowContextMappings, mergeFlowContextStats, buildFlowContextQuery } from '../../flow-context.js';
 import { declareCapabilities } from '../../capabilities.js';
 
 declareCapabilities('flows', { mutationSubcommands: ['create', 'update', 'delete'], devAlias: true });
@@ -66,6 +67,62 @@ export function flowsCmd(wrap) {
             }, { summary: `${records.length} flow(s)` });
           }),
         })
+        .command({
+          command: 'executions',
+          aliases: ['runs', 'contexts'],
+          describe: 'Show Flow Designer executions from sys_flow_context',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query (e.g. "state=WAITING" or "source_record=<sys_id>")' })
+            .option('record', { type: 'string', describe: 'Only executions for this source record sys_id' })
+            .option('since', { type: 'string', describe: 'Only contexts created on or after this timestamp' })
+            .option('until', { type: 'string', describe: 'Only contexts created on or before this timestamp' })
+            .option('limit', { alias: 'l', type: 'number', default: 50, describe: 'Max executions' })
+            .option('summary', { type: 'boolean', default: false, describe: 'Return local counts and duration metrics by flow' })
+            .option('active', { type: 'boolean', default: false, describe: 'Only waiting, running, and queued executions' })
+            .option('all', { type: 'boolean', default: false, describe: 'Compatibility flag; all states are now shown by default' }),
+          handler: wrap(async (argv, app) => {
+            app.requireInstance();
+            const fields = await discoverFlowContextFields(app.sdk);
+            const query = buildFlowContextQuery({
+              record: argv.record,
+              since: argv.since,
+              until: argv.until,
+              query: argv.query || (argv.active ? 'stateINWAITING,RUNNING,QUEUED' : ''),
+            });
+            const params = new URLSearchParams();
+            params.set('sysparm_query', query);
+            params.set('sysparm_limit', String(argv.limit));
+            params.set('sysparm_fields', [...fields].join(','));
+            params.set('sysparm_display_value', 'all');
+            const records = await app.sdk.list('sys_flow_context', params);
+            const executions = records.map(record => normalizeFlowContext(record));
+            const sampledSummary = summarizeFlowContexts(executions);
+            let executionSummary = sampledSummary;
+            if (argv.summary) {
+              const [totalCount, stats] = await Promise.all([
+                app.sdk.aggregateCount('sys_flow_context', query).catch(() => null),
+                app.sdk.aggregate('sys_flow_context', { query, groupBy: ['name', 'state'], count: true }).catch(() => null),
+              ]);
+              executionSummary = mergeFlowContextStats(stats?.groups || stats?.stats || [], sampledSummary, totalCount);
+            }
+            const data = {
+              table: 'sys_flow_context',
+              count: argv.summary ? executionSummary.total_count ?? executions.length : executions.length,
+              sample_count: executions.length,
+              query,
+              fields: [...fields],
+              field_mapping: aggregateFlowContextMappings(executions),
+              missing_fields: [...new Set(executions.flatMap(execution => execution.missing_fields))],
+              summary: executionSummary,
+              executions: argv.summary ? undefined : executions,
+              _formatted: argv.summary ? formatFlowContextSummary(executionSummary) : undefined,
+              context: { instance_url: app.getEffectiveInstance(), timezone: 'UTC' },
+            };
+            app.ok(data, { summary: argv.summary
+              ? `${executionSummary.total_count ?? executions.length} matching flow execution(s), ${executions.length} sampled`
+              : `${executions.length} flow execution(s)` });
+          }),
+        })
         .command({
           command: 'show <identifier>',
           aliases: ['get'],
@@ -128,6 +185,7 @@ export function flowsCmd(wrap) {
       console.log('');
       console.log('Available subcommands:');
       console.log('  list                  List flows');
+      console.log('  executions            Show flow executions from sys_flow_context');
       console.log('  show <identifier>     Show flow details by name or sys_id');
       console.log('  create                Create a new flow (not yet implemented)');
       console.log('  update <identifier>   Update a flow (not yet implemented)');
@@ -650,10 +708,66 @@ async function formatStepLine(stepNum, pad, step, ctx) {
     case 'subflow':
       return formatSubFlowStep(stepNum, pad, step.data, ctx);
     default:
-      return formatActionStep(stepNum, pad, step.data, ctx);
+      return formatActionStepWithChildren(stepNum, pad, step.data, ctx);
+  }
+}
+
+async function formatActionStepWithChildren(stepNum, pad, action, ctx) {
+  const lines = formatActionStep(stepNum, pad, action, ctx);
+  const depth = ctx?.depth ?? 1;
+  if (!ctx?.sdk?.inspectCustomAction || depth <= 1) return lines;
+
+  const actionName = getActionName(action);
+  if (!actionName) return lines;
+
+  if (!ctx.customActionCache) ctx.customActionCache = new Map();
+  if (!ctx.customActionCache.has(actionName)) {
+    ctx.customActionCache.set(actionName, ctx.sdk.inspectCustomAction(actionName).catch(() => null));
+  }
+  const details = await ctx.customActionCache.get(actionName);
+  const steps = details?.steps;
+  if (!Array.isArray(steps) || steps.length === 0 || !hasUsefulActionSteps(actionName, steps)) return lines;
+
+  lines.push(`${pad}   ↳ Internal action steps`);
+  const ordered = [...steps].sort((a, b) => parseOrderField(a) - parseOrderField(b));
+  ordered.forEach((step, index) => {
+    const label = firstNonEmpty(getStringField(step, 'label'), getStringField(step, 'name'), 'Action step');
+    const type = getNestedString(step, 'step_type', 'display_value') || getStringField(step, 'step_type');
+    const suffix = type ? ` - ${type}` : '';
+    lines.push(`${pad}      Step ${index + 1}: ${label}${suffix}`);
+    appendStepValues(lines, pad + '         ', step, ctx);
+  });
+  return lines;
+}
+
+function hasUsefulActionSteps(actionName, steps) {
+  if (steps.length !== 1) return true;
+  const step = steps[0];
+  const label = firstNonEmpty(getStringField(step, 'label'), getStringField(step, 'name'))
+    .replace(/\s+step$/i, '').trim().toLowerCase();
+  return label !== actionName.trim().toLowerCase();
+}
+
+function appendStepValues(lines, pad, step, ctx) {
+  for (const field of ['inputs', 'outputs', 'extended_inputs', 'extended_outputs']) {
+    const value = getStringField(step, field);
+    if (!value) continue;
+    const resolved = resolveGuidPills(value, ctx?.labelCache);
+    for (const part of resolved.split('^')) {
+      if (part) lines.push(`${pad}${field}: ${part}`);
+    }
   }
 }
 
+function getActionName(action) {
+  return firstNonEmpty(
+    getNestedString(action, 'actionType', 'fName'),
+    getStringField(action, 'actionName'),
+    getStringField(action, 'actionInternalName'),
+    getStringField(action, 'name'),
+  );
+}
+
 export function formatActionStep(stepNum, pad, action, ctx) {
   const lines = [];
   let actionName = firstNonEmpty(
@@ -700,7 +814,6 @@ export function formatActionStep(stepNum, pad, action, ctx) {
       if (inputName === 'table_name' && showsTableSuffix) continue;
 
       let inputValue = firstNonEmpty(getStringField(raw, 'displayValue'), getStringField(raw, 'value'));
-      if (!inputValue) continue;
 
       // Catalog variable selections arrive as "sys_id:table" pairs; resolve
       // them to readable names when we have a resolver map (built per flow).
@@ -716,6 +829,11 @@ export function formatActionStep(stepNum, pad, action, ctx) {
         label = firstNonEmpty(getStringField(raw.parameter, 'label'), label);
       }
 
+      if (!inputValue) {
+        lines.push(`${pad}    ${label}: (not set)`);
+        continue;
+      }
+
       // ServiceNow writes multi-field payloads (encoded-query style) as
       // "field=value^field2=value2". Split those onto one line per field;
       // plain long strings stay on a single line, untruncated.

package/src/commands/dev/rest.js

@@ -26,6 +26,11 @@ export function restCmd(wrap) {
           type: 'string',
           describe: 'Table name shorthand for api/now/table/{table}',
         })
+        .option('raw', {
+          type: 'boolean',
+          default: false,
+          describe: 'Return non-JSON response bodies as text (for XML/HTML diagnostic endpoints)',
+        })
         .option('query', {
           type: 'string',
           describe: 'Query parameters string',
@@ -63,7 +68,9 @@ export function restCmd(wrap) {
         requestOptions.body = argv.data;
       }
 
-      const result = await app.sdk.request(url, requestOptions);
+      const result = argv.raw
+        ? await app.sdk.rawRequest(url, requestOptions)
+        : await app.sdk.request(url, requestOptions);
       app.ok(result, { summary: `${method} ${endpoint}` });
     }),
   };