@jacebenson/jsn 4.3.9-dev.63 → 4.3.9-dev.65

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/updatesets.js

@@ -6,6 +6,8 @@ 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

package/src/prompts.js

@@ -0,0 +1,37 @@
+import * as prompts from '@inquirer/prompts';
+
+export class PromptCancelled extends Error {
+  constructor() {
+    super('Cancelled.');
+    this.name = 'PromptCancelled';
+  }
+}
+
+/** Add Escape cancellation to an Inquirer prompt without changing its answers. */
+export function cancellablePrompt(prompt) {
+  return async (config, context = {}) => {
+    const input = context.input || process.stdin;
+    const controller = new AbortController();
+    const onKey = (_value, key) => {
+      if (key?.name === 'escape') controller.abort(new PromptCancelled());
+    };
+    input.on('keypress', onKey);
+    try {
+      return await prompt({ ...config, message: `${config.message} (Esc to cancel)` }, {
+        ...context,
+        signal: context.signal ? AbortSignal.any([context.signal, controller.signal]) : controller.signal,
+      });
+    } catch (error) {
+      if (controller.signal.aborted) throw controller.signal.reason;
+      throw error;
+    } finally {
+      input.removeListener('keypress', onKey);
+    }
+  };
+}
+
+export const input = cancellablePrompt(prompts.input);
+export const password = cancellablePrompt(prompts.password);
+export const select = cancellablePrompt(prompts.select);
+export const search = cancellablePrompt(prompts.search);
+export const confirm = cancellablePrompt(prompts.confirm);