@jacebenson/jsn 4.3.9 → 4.3.10-dev.67

package/src/commands/flows.js

@@ -21,7 +21,7 @@ const FLOW_COMMANDS = [
   { name: 'publish [identifier]', description: 'Publish (activate) a flow, or a custom action with --action' },
   { name: 'test [identifier]', description: 'Execute a record-triggered flow against one record' },
   { name: 'create', description: 'Create a draft flow: guided in a terminal, JSON manifest in scripts' },
-  { name: 'update [identifier]', description: 'Update a draft flow (alias: edit)' },
+  { name: 'update [identifier]', description: 'Update a draft, or a published flow whose definition reports write access (alias: edit)' },
   { name: 'doctor', description: 'Check whether this instance can publish flows at all' },
   { name: 'delete [identifier]', description: 'Delete a flow (not implemented: use the Flow Designer UI)' },
 ];
@@ -341,15 +341,19 @@ export function flowsCmd(wrap) {
         .command({
           command: 'update [identifier]',
           aliases: ['edit'],
-          describe: 'Safely update an inactive Draft flow from a partial JSON manifest. Use `jsn flows schemas` for live trigger inputs and `jsn actions action-type-schema --id <actionTypeId> --scope <scopeId>` for provider action inputs. Manifest structure remains code-owned; omitted values are preserved.',
+          describe: 'Save partial edits to a Draft, or to a published/active flow whose ProcessFlow definition reports security.can_write=true: record_create_or_update trigger table/condition and existing action inputs. Published flows are edited as their working definition; the published snapshot and runtime pointers must stay unchanged, and the command fails loudly if they do not. Flows without write access are refused before any lock or content write, naming the permission. Use --preview for before/after values without writes. Flow Logic, variables, catalog-trigger edits and stage placement require Flow Designer. Never publishes or executes. Use `jsn flows schemas` and `jsn actions action-type-schema --id <actionTypeId> --scope <scopeId>` for live schemas; omitted values are preserved.',
           builder: (y) => y
             .option('data', { type: 'string', describe: 'Update manifest as inline JSON' })
             .option('data-file', { type: 'string', describe: 'Read the update manifest from a JSON file' })
+            .option('preview', { type: 'boolean', default: false, describe: 'Validate and show exact before/after input values without saving or versioning' })
             .option('force', { type: 'boolean', default: false, describe: 'Skip confirmation' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
             const dataFile = argv.dataFile ?? argv['data-file'];
-            const identifier = await pickFlow(argv, app, !hasDefinitionData(argv) ? 'active=false^status=draft' : '');
+            // No lifecycle filter: published flows are editable when their own
+            // definition reports write access, and a non-writable target is
+            // refused with a permission message rather than a lifecycle label.
+            const identifier = await pickFlow(argv, app);
             if (identifier === undefined) return;
             argv = { ...argv, identifier };
             let manifest;
@@ -360,13 +364,19 @@ export function flowsCmd(wrap) {
             } catch (error) {
               throw new Error(`Invalid flow update manifest JSON: ${error.message}`, { cause: error });
             }
-            await confirmDesignerMutation(argv, app, `Update draft flow ${identifier}; unspecified components and inputs are preserved`);
+            if (!argv.preview) await confirmDesignerMutation(argv, app, `Update flow ${identifier}; unspecified components and inputs are preserved. A published flow is edited as its working definition: the published snapshot must stay unchanged.`);
             const result = await updateFlowFromManifest(app.sdk, app.getEffectiveInstance(), argv.identifier, manifest, {
+              preview: argv.preview,
               readUpdateSet: () => readCurrentUpdateSet(app.sdk),
             });
-            return app.ok(result, {
-              summary: `Updated draft flow "${result.flow.name}" (${result.flow.id}) without activation`,
-              breadcrumbs: [{ action: 'show', cmd: `jsn flows show ${result.flow.id}`, description: 'Inspect the updated draft flow' }],
+            const diff = result.changes.map(change => `${change.component}${change.order ? ` ${change.order}` : ''}.${change.input}: ${JSON.stringify(change.before)} -> ${JSON.stringify(change.after)}`).join('\n');
+            const state = `${result.flow.status}${result.flow.active ? ', active' : ''}`;
+            const preservation = result.lifecycle?.published && !result.preview
+              ? `; published snapshot ${result.runtime_preservation?.before?.published_definition?.snapshot_id ?? ''} unchanged`
+              : '';
+            return app.ok({ ...result, _formatted: diff }, {
+              summary: `${result.preview ? 'Preview for' : 'Updated'} flow "${result.flow.name}" (${result.flow.id}) in state ${state}${preservation} without activation`,
+              breadcrumbs: [{ action: 'show', cmd: `jsn flows show ${result.flow.id}`, description: 'Inspect the updated flow' }],
             });
           }),
         })

package/src/commands/midservers.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import { input, password as passwordPrompt, select } from '@inquirer/prompts';
+import { input, password as passwordPrompt, select } from '../prompts.js';
 import { confirmDelete, formatRecordForDisplay, getStringField, interactiveList, canPrompt, assertSafeExactMatch } from '../helpers.js';
 import { FormatAuto } from '../output.js';
 import { declareCapabilities } from '../capabilities.js';

package/src/commands/setup.js

@@ -1,18 +1,20 @@
 import { createPrompt, useKeypress, usePagination, useState, isDownKey, isEnterKey, isUpKey } from '@inquirer/core';
-import { loginWizard, modifyProfile, removeProfile, pickProfile } from './auth.js';
-import { setActiveProfile } from '../config.js';
+import { loginWizard, loginProfile, showAuthStatus, switchProfile, modifyProfile, logoutProfile, removeConnection } from './auth.js';
 import { errUsage } from '../errors.js';
 import { declareCapabilities } from '../capabilities.js';
 
 // Setup manages local profile config — runs without a configured instance.
 // (Not in the daily-check skip-list: legacy behavior checks for updates here.)
-declareCapabilities('setup', { noInstance: true });
+declareCapabilities('setup', { noInstance: true, skipContextHeader: true });
 
 const HUB_CHOICES = [
-  { name: 'Add a new instance', value: 'add' },
-  { name: 'Switch to a different instance', value: 'switch' },
-  { name: 'Remove an instance', value: 'remove' },
-  { name: 'Modify an instance', value: 'modify' },
+  { name: 'Add a connection', value: 'add' },
+  { name: 'Sign in again', value: 'login' },
+  { name: 'Check connections', value: 'status' },
+  { name: 'Choose the default profile', value: 'switch' },
+  { name: 'Change settings', value: 'modify' },
+  { name: 'Sign out (keep the profile)', value: 'logout' },
+  { name: 'Remove a connection', value: 'remove' },
 ];
 
 /** The setup hub prompt; q and Escape resolve with no selected action. */
@@ -54,41 +56,44 @@ export async function authHubMenu({ promptFn = authHubPrompt, input, output } =
  */
 export async function dispatchSetupAction(app, argv, action) {
   if (action === 'add') {
-    const result = await loginWizard(app, argv);
-    app.ok({ setup: true, ...result }, { summary: 'Setup complete' });
+    return loginWizard(app, argv);
+  } else if (action === 'login') {
+    return loginProfile(argv, app);
+  } else if (action === 'status') {
+    return showAuthStatus(argv, app);
   } else if (action === 'switch') {
-    const name = await pickProfile(app, 'Switch to which instance?');
-    await setActiveProfile(app.config, name);
-    app.ok({ active_profile: name }, { summary: `Active profile: ${name}` });
+    return switchProfile(argv, app);
+  } else if (action === 'logout') {
+    return logoutProfile(argv, app);
   } else if (action === 'remove') {
-    const name = await pickProfile(app, 'Remove which instance?');
-    await removeProfile(app, name);
+    return removeConnection(argv, app);
   } else if (action === 'modify') {
-    await modifyProfile(app, argv);
+    return modifyProfile(app, argv);
   }
 }
 
 // `jsn setup` is the interactive front door for managing instances.
 // The granular, scriptable surface lives under `jsn auth` — this command
-// dispatches to the SAME functions (loginWizard, setActiveProfile,
-// removeProfile, modifyProfile) so the two surfaces can never drift.
+// collects choices and dispatches to the same auth operations.
 export function setupCmd(wrap) {
   return {
     command: 'setup',
     describe: 'Set up and manage your ServiceNow instances (interactive)',
     handler: wrap(async (argv, app) => {
-      if (!app.isInteractive()) {
+      const { canUsePicker } = await import('../helpers.js');
+      if (!app.isInteractive() || !canUsePicker(app, argv)) {
         throw errUsage('"jsn setup" is interactive. Use the specific commands:\n  jsn auth login <instance>\n  jsn auth refresh\n  jsn auth status');
       }
       const profileNames = Object.keys(app.config.profiles || {});
       if (profileNames.length === 0) {
         const result = await loginWizard(app, argv);
-        app.ok({ setup: true, ...result }, { summary: 'Setup complete' });
+        await showAuthStatus({ ...argv, profile: result.profileName }, app);
         return;
       }
       const action = await authHubMenu();
       if (action === undefined) return;
-      await dispatchSetupAction(app, argv, action);
+      const result = await dispatchSetupAction(app, argv, action);
+      if (action !== 'status') await showAuthStatus({ ...argv, profile: result?.profile || result?.profileName }, app);
     }),
   };
 }

package/src/commands/skill.js

@@ -333,7 +333,7 @@ export function skillCmd(wrap) {
                 ? `Where should the jsn skill be installed? (${outdated.length} outdated)`
                 : 'Where should the jsn skill be installed?';
 
-              const { checkbox } = await import('@inquirer/prompts');
+              const { checkbox } = await import('../prompts.js');
               const choices = Object.entries(TARGET_NAMES).map(([key, label]) => {
                 const dir = AGENT_SKILL_DIRS[key];
                 const targetPath = key === 'cursor'

package/src/commands/skipped-updates.js

@@ -1,4 +1,4 @@
-import { checkbox, select, confirm } from '@inquirer/prompts';
+import { checkbox, select, confirm } from '../prompts.js';
 import { canUsePicker, interactiveList, getStringField } from '../helpers.js';
 import { declareCapabilities } from '../capabilities.js';
 import { errUsage } from '../errors.js';

package/src/commands/updatesets.js

@@ -1,11 +1,13 @@
 import fs from 'node:fs';
-import { editor, confirm } from '@inquirer/prompts';
+import { editor, confirm } from '../prompts.js';
 import { formatRecordForDisplay, getStringField, interactiveList, assertSafeExactMatch, canPrompt, buildRerunCommand, verifyWriteBack } from '../helpers.js';
 import { getActiveProfile } from '../config.js';
 import { FormatAuto } from '../output.js';
 import { getCurrentApplication, getCurrentUpdateSet, requireCurrentUserSysId, setCurrentApplication, setCurrentUpdateSet } from '../context.js';
 import { errAPI, errUsage, errConfirmationRequired } from '../errors.js';
 import { declareCapabilities } from '../capabilities.js';
+import { resolveScope } from './scopes.js';
+import { unwrapSysId } from '../resolve-record.js';
 
 declareCapabilities('updatesets', {
   mutationSubcommands: ['create', 'set', 'complete', 'ignore', 'parent'],
@@ -612,12 +614,22 @@ export function updateSetsCmd(wrap) {
           describe: 'Create a new update set (auto-sets as current)',
           builder: (y) => y
             .option('name', { alias: 'n', type: 'string', demandOption: true, describe: 'Update set name' })
-            .option('description', { type: 'string', describe: 'Description' }),
+            .option('description', { type: 'string', describe: 'Description' })
+            .option('scope', { type: 'string', describe: 'Switch to this application before creating (scope value, sys_id, or name)' }),
           handler: wrap(async (argv, app) => {
+            let scopeSysID;
+            if (argv.scope !== undefined) {
+              if (!String(argv.scope).trim()) throw errUsage('Scope must not be empty');
+              const scope = await resolveScope(app.sdk, argv.scope);
+              scopeSysID = unwrapSysId(scope);
+              const userSysID = await requireCurrentUserSysId(app.sdk);
+              await setCurrentApplication(app.sdk, userSysID, scopeSysID);
+            }
             const record = await app.sdk.create('sys_update_set', {
               name: argv.name,
               description: argv.description || argv.name,
               state: 'in progress',
+              ...(scopeSysID ? { application: scopeSysID } : {}),
             });
 
             // Auto-set as current update set

package/src/errors.js

@@ -219,8 +219,16 @@ function resolveJsonMode(app, argv) {
  *   text is null when the error was rendered through app.err (envelope).
  */
 export function renderAppError(err, { app = null, argv = null, identifier = '' } = {}) {
+  if (err.name === 'PromptCancelled') return { stream: 'stderr', text: 'Cancelled.\n', exitCode: 0 };
   const code = err.code || 'unknown';
 
+  if (code === CodeAuth) {
+    if (resolveJsonMode(app, argv) && app) return { stream: 'stdout', text: null, exitCode: 1, appErr: true };
+    let text = `Error (auth): ${err.message}\n`;
+    if (err.hint) text += `\nHint: ${err.hint}\n`;
+    return { stream: 'stderr', text, exitCode: 1 };
+  }
+
   if (code === CodeConfirmationRequired) {
     // Structured error for AI agents / piped consumers: the JSON envelope
     // goes to stdout (where tooling reads) so the agent can surface the