@jacebenson/jsn 4.3.12 → 4.3.13-dev.101.1

package/src/commands/scopes.js

@@ -3,7 +3,7 @@ import { requireCurrentUserSysId, setCurrentApplication } from '../context.js';
 import { declareCapabilities } from '../capabilities.js';
 import { unwrapSysId } from '../resolve-record.js';
 
-declareCapabilities('scopes', { mutationSubcommands: ['create', 'set'] });
+declareCapabilities('scopes', { mutationSubcommands: ['create', 'set'], mutationContextExemptSubcommands: ['create', 'set'] });
 
 /**
  * Resolve a scope identifier to a single sys_scope record.

package/src/commands/setup.js

@@ -1,5 +1,5 @@
 import { loginWizard, loginProfile, showAuthStatus, switchProfile, modifyProfile, logoutProfile, removeConnection } from './auth.js';
-import { errUsage } from '../errors.js';
+import { errUsageHint } from '../errors.js';
 import { declareCapabilities } from '../capabilities.js';
 
 // Setup manages local profile config — runs without a configured instance.
@@ -7,15 +7,36 @@ import { declareCapabilities } from '../capabilities.js';
 declareCapabilities('setup', { noInstance: true, skipContextHeader: true });
 
 const HUB_CHOICES = [
-  { 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' },
+  { name: 'Add a connection', value: 'add', command: 'jsn auth login <instance> --name <name> --basic' },
+  { name: 'Sign in again', value: 'login', command: 'jsn auth login --profile <name> (with the authentication options below)' },
+  { name: 'Check connections', value: 'status', command: 'jsn auth status --details --json (use --local to skip instance probes)' },
+  { name: 'Choose the default profile', value: 'switch', command: 'jsn auth switch <name>' },
+  { name: 'Change settings', value: 'modify', command: 'jsn auth modify --profile <name> --read-only --confirm-deletes --no-include-counts' },
+  { name: 'Sign out (keep the profile)', value: 'logout', command: 'jsn auth logout --profile <name> --force (only after explicit approval)' },
+  { name: 'Remove a connection', value: 'remove', command: 'jsn auth remove <name>' },
+  { name: 'Install optional offline documentation', value: 'docs', command: 'jsn docs install --source snapshot|github|skip' },
 ];
 
+const setupHelp = () => [
+  'With no profiles, setup opens the add-connection wizard; otherwise it opens the management menu.',
+  'The wizard and these scriptable commands share the same authentication and configuration operations:',
+  ...HUB_CHOICES.map(choice => `  ${choice.name}: ${choice.command}`),
+  '',
+  'Authentication input without secrets in command arguments:',
+  '  Basic: set SN_USERNAME and SN_PASSWORD through your environment, then use --basic.',
+  '  OAuth: jsn auth login <instance> --name <name> --oauth --print-url --wait-file <code-file> --json',
+  '  Browser session: jsn auth login <instance> --name <name> --headers-file <session-file> --json',
+  '  Piped browser session: jsn auth login <instance> --name <name> --headers-file - --json',
+  '  A browser window can also be requested explicitly with --browser; it requires a human to sign in.',
+  '  Refresh OAuth: jsn auth refresh --profile <name>',
+  '  Renew captured browser headers: jsn auth refresh --profile <name> --headers-file <session-file>',
+  '',
+  'New-profile preferences: --read-only, --confirm-deletes, --include-counts and --make-default.',
+  'Use --no-read-only, --no-confirm-deletes, --no-include-counts or --no-make-default for the opposite value.',
+  'Use --json for structured output. Explicit flags avoid implicit pickers; ambiguous targets return an error.',
+  'Discover all options with jsn auth <command> --help.',
+].join('\n');
+
 /** The setup hub prompt; q and Escape resolve with no selected action. */
 export const authHubPrompt = async (...args) => {
   const { createPrompt, useKeypress, usePagination, useState, isDownKey, isEnterKey, isUpKey } = await import('@inquirer/core');
@@ -81,19 +102,35 @@ export function setupCmd(wrap) {
   return {
     command: 'setup',
     describe: 'Set up and manage your ServiceNow instances (interactive)',
+    builder: y => y.option('docs-source', { type: 'string', choices: ['snapshot', 'github', 'skip'], describe: 'Install optional documentation directly without the authentication wizard' }).epilogue(setupHelp()),
     handler: wrap(async (argv, app) => {
+      if (argv['docs-source']) {
+        const { installDocumentation } = await import('./docs/install.js');
+        app.ok(await installDocumentation(argv['docs-source']));
+        return;
+      }
       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');
+        throw errUsageHint('"jsn setup" is interactive. Use explicit auth commands instead.', setupHelp());
       }
       const profileNames = Object.keys(app.config.profiles || {});
       if (profileNames.length === 0) {
         const result = await loginWizard(app, argv);
         await showAuthStatus({ ...argv, profile: result.profileName }, app);
+        const { docsDbExists } = await import('./docs/db.js');
+        if (!docsDbExists()) {
+          const { offerDocumentation } = await import('./docs/install.js');
+          app.ok(await offerDocumentation(app, argv));
+        }
         return;
       }
       const action = await authHubMenu();
       if (action === undefined) return;
+      if (action === 'docs') {
+        const { offerDocumentation } = await import('./docs/install.js');
+        app.ok(await offerDocumentation(app, argv));
+        return;
+      }
       const result = await dispatchSetupAction(app, argv, action);
       if (action !== 'status') await showAuthStatus({ ...argv, profile: result?.profile || result?.profileName }, app);
     }),

package/src/commands/skill.js

@@ -18,8 +18,6 @@ const SKILL_REPO_PATH = path.join(
   '..', '..', 'skills', SKILL_NAME, 'SKILL.md'
 );
 
-const SKILL_RAW_URL = 'https://raw.githubusercontent.com/jacebenson/jsn/main/skills/servicenow/SKILL.md';
-
 /**
  * Resolve the user's real home directory, even when Hermes overrides $HOME.
  */
@@ -119,62 +117,56 @@ function saveSkillConfig(updates) {
   fs.writeFileSync(globalConfigPath(), JSON.stringify(cfg, null, 2), { mode: 0o600 });
 }
 
-function recordSkillInstall(targetPath) {
-  const bundled = readBundledSkill();
-  const version = extractVersion(bundled) || 'unknown';
+function replaceSkill(targetPath, content) {
+  const temporary = `${targetPath}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(temporary, content, { encoding: 'utf-8', mode: 0o600 });
+    fs.renameSync(temporary, targetPath);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+function recordSkillInstall(targetPaths, content) {
+  const version = extractVersion(content) || 'unknown';
   saveSkillConfig({
-    skillLocation: targetPath,
+    skillLocation: targetPaths[0],
+    skillLocations: targetPaths,
     skillVersion: version,
     skillLastChecked: new Date().toISOString(),
   });
 }
 
-// ── Skill version check (once per day, uses recorded location) ──
-
-export function checkSkill() {
+// Compare bytes, including edits that retain the same version number.
+export function checkSkill({ warn = true } = {}) {
   const cfg = loadSkillConfig();
-  const location = cfg.skillLocation;
-  if (!location) return { current: true, note: 'Skill not installed — run "jsn skill install"' };
-
-  // Throttle: skip if checked within last 24 hours
-  if (cfg.skillLastChecked) {
-    const elapsed = Date.now() - new Date(cfg.skillLastChecked).getTime();
-    if (elapsed < 86400000) return { current: true, note: 'Checked within 24h — skipping' };
-  }
-
-  let installed;
-  try {
-    installed = fs.readFileSync(location, 'utf-8');
-  } catch {
-    return { current: true, note: `Skill file not found at ${location} — run "jsn skill install"` };
-  }
-
-  const installedVersion = extractVersion(installed);
+  const locations = cfg.skillLocations || (cfg.skillLocation ? [cfg.skillLocation] : []);
   const bundled = readBundledSkill();
-  const bundledVersion = extractVersion(bundled);
-
-  if (!installedVersion || !bundledVersion) {
-    return { current: true, error: 'Could not determine skill version' };
-  }
-
-  const current = installedVersion === bundledVersion;
-
-  if (!current) {
-    process.stderr.write(
-      `\n⚠ jsn: ServiceNow skill is outdated (installed v${installedVersion}, bundled v${bundledVersion}).\n` +
-      `  Run "jsn skill install" to update.\n\n`
-    );
-  }
-
-  // Update last-checked timestamp
+  if (bundled === null) return { current: false, error: 'Bundled skill missing; reinstall jsn.' };
+  if (!locations.length) return { current: false, note: 'Skill not installed — run "jsn skill install"' };
+  const copies = locations.map(location => {
+    let installed;
+    try { installed = fs.readFileSync(location, 'utf-8'); } catch {
+      return { location, current: false, status: 'missing' };
+    }
+    const current = installed === bundled;
+    const actual = installed.split('\n');
+    const expected = bundled.split('\n');
+    const line = current ? undefined : Array.from({ length: Math.max(actual.length, expected.length) }, (_, i) => i)
+      .find(i => actual[i] !== expected[i]) + 1;
+    return { location, current, status: current ? 'matching' : 'different',
+      installed_version: extractVersion(installed), first_different_line: line };
+  });
+  const current = copies.every(copy => copy.current);
+  if (!current && warn) process.stderr.write('ServiceNow skill differs from the packaged copy. Run "jsn skill check" for locations or "jsn skill install" to replace it.\n');
   saveSkillConfig({ skillLastChecked: new Date().toISOString() });
-
-  return { current, installed_version: installedVersion, bundled_version: bundledVersion };
+  return { current, installed_version: copies[0].installed_version,
+    bundled_version: extractVersion(bundled), copies };
 }
 
 function extractVersion(content) {
   // Matches version in YAML frontmatter (top-level or nested under metadata:)
-  const m = content.match(/^\s*version:\s*["']?(.+?)["']?\s*$/m);
+  const m = (content || '').match(/^\s*version:\s*["']?(.+?)["']?\s*$/m);
   return m ? m[1] : null;
 }
 
@@ -205,9 +197,9 @@ export function skillCmd(wrap) {
         })
         .command({
           command: 'check',
-          describe: 'Check if the installed skill matches the bundled version',
+          describe: 'Compare installed skill contents with the packaged skill',
           handler: wrap(async (_argv, app) => {
-            const result = checkSkill();
+            const result = checkSkill({ warn: false });
 
             let summary;
             if (result.error) {
@@ -215,21 +207,21 @@ export function skillCmd(wrap) {
             } else if (result.note) {
               summary = result.note;
             } else if (result.current) {
-              summary = `✓ Skill is current (v${result.installed_version} matches bundled v${result.bundled_version})`;
+              summary = `✓ Skill contents match the packaged copy (v${result.bundled_version})`;
             } else {
-              summary = `⚠ Skill outdated: installed v${result.installed_version} vs bundled v${result.bundled_version} — run "jsn skill install" to update`;
+              summary = `⚠ Skill contents differ — run "jsn skill install" to replace installed copies`;
             }
 
-            app.ok(result, { summary });
+            const details = result.copies?.map(copy => `${copy.status}: ${copy.location}${copy.first_different_line ? ` (first difference: line ${copy.first_different_line})` : ''}`).join('\n');
+            app.ok({ ...result, _formatted: [summary, details].filter(Boolean).join('\n') }, { summary });
           }),
         })
         .command({
           command: 'fetch',
-          describe: 'Download the latest skill file from GitHub to stdout',
+          describe: 'Print the packaged skill to stdout (offline)',
           handler: wrap(async (_argv, _app) => {
-            const res = await fetch(SKILL_RAW_URL);
-            if (!res.ok) throw new Error(`Failed to fetch skill: ${res.status} ${res.statusText}`);
-            const content = await res.text();
+            const content = readBundledSkill();
+            if (content === null) throw new Error('Bundled skill missing; reinstall jsn.');
             process.stdout.write(content);
           }),
         })
@@ -246,7 +238,6 @@ export function skillCmd(wrap) {
             app.ok({
               bundled: SKILL_REPO_PATH,
               targets: allPaths,
-              raw_url: SKILL_RAW_URL,
             }, {
               summary: 'Skill file locations and install targets',
               breadcrumbs: [
@@ -260,7 +251,7 @@ export function skillCmd(wrap) {
         })
         .command({
           command: 'install [dir]',
-          describe: 'Download and save the latest skill file',
+          describe: 'Install the bundled skill matched to this CLI version',
           builder: (y) => y
             .positional('dir', {
               type: 'string',
@@ -268,12 +259,13 @@ export function skillCmd(wrap) {
             })
             .option('target', {
               type: 'string',
-              describe: 'Target agent(s): hermes, copilot, vscode, claude, cursor, agents, opencode, openclaw, codex, or "all" (comma-separated). Omit for interactive picker.',
+              describe: 'Target agent(s): hermes, copilot, vscode, claude, cursor, agents, opencode, openclaw, codex, or "all" (comma-separated). Omit to replace recorded copies, or choose targets on first install.',
             }),
           handler: wrap(async (argv, app) => {
-            const res = await fetch(SKILL_RAW_URL);
-            if (!res.ok) throw new Error(`Failed to fetch skill: ${res.status} ${res.statusText}`);
-            const content = await res.text();
+            const content = readBundledSkill();
+            if (!content) {
+              throw new Error('Skill file not found in package (expected at skills/servicenow/SKILL.md). Reinstall jsn to restore it.');
+            }
 
             // Resolve target directories
             let targets = [];
@@ -283,7 +275,7 @@ export function skillCmd(wrap) {
               const p = path.resolve(argv.dir);
               fs.mkdirSync(p, { recursive: true });
               const targetPath = path.join(p, 'SKILL.md');
-              fs.writeFileSync(targetPath, content, 'utf-8');
+              replaceSkill(targetPath, content);
               targets.push({ name: path.basename(argv.dir), path: targetPath });
             } else if (argv.target) {
               // Explicit --target: install to specified agents
@@ -296,38 +288,41 @@ export function skillCmd(wrap) {
                   if (key === 'cursor') {
                     fs.mkdirSync(dir, { recursive: true });
                     const targetPath = path.join(dir, `${SKILL_NAME}.mdc`);
-                    fs.writeFileSync(targetPath, content, 'utf-8');
+                    replaceSkill(targetPath, content);
                     targets.push({ name: TARGET_NAMES[key], path: targetPath });
                   } else {
                     fs.mkdirSync(dir, { recursive: true });
                     const targetPath = path.join(dir, 'SKILL.md');
-                    fs.writeFileSync(targetPath, content, 'utf-8');
+                    replaceSkill(targetPath, content);
                     targets.push({ name: TARGET_NAMES[key], path: targetPath });
                   }
                 }
               }
+            } else if (loadSkillConfig().skillLocation) {
+              const cfg = loadSkillConfig();
+              for (const targetPath of cfg.skillLocations || [cfg.skillLocation]) {
+                fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+                replaceSkill(targetPath, content);
+                targets.push({ name: targetPath, path: targetPath });
+              }
             } else if (canUsePicker(app, argv)) {
               // Interactive: show multi-select picker. canUsePicker() (not a
               // bare stdin TTY check) keeps a PTY allocated for an agent,
               // CI, JSN_NO_PROMPTS, --json/--quiet or --get out of a prompt.
-              const fetchedVersion = extractVersion(content);
               // Check if any existing installed copies are outdated
               const outdated = [];
-              if (fetchedVersion) {
-                for (const [key, dir] of Object.entries(AGENT_SKILL_DIRS)) {
+              for (const [key, dir] of Object.entries(AGENT_SKILL_DIRS)) {
                   const skillPath = key === 'cursor'
                     ? path.join(dir, `${SKILL_NAME}.mdc`)
                     : path.join(dir, 'SKILL.md');
                   try {
                     const existing = fs.readFileSync(skillPath, 'utf-8');
-                    const existingVersion = extractVersion(existing);
-                    if (existingVersion && existingVersion !== fetchedVersion) {
+                    if (existing !== content) {
                       outdated.push(TARGET_NAMES[key]);
                     }
                   } catch {
                     // Not installed — skip
                   }
-                }
               }
               const promptMsg = outdated.length > 0
                 ? `Where should the jsn skill be installed? (${outdated.length} outdated)`
@@ -366,12 +361,12 @@ export function skillCmd(wrap) {
                 if (key === 'cursor') {
                   fs.mkdirSync(dir, { recursive: true });
                   const targetPath = path.join(dir, `${SKILL_NAME}.mdc`);
-                  fs.writeFileSync(targetPath, content, 'utf-8');
+                  replaceSkill(targetPath, content);
                   targets.push({ name: TARGET_NAMES[key], path: targetPath });
                 } else {
                   fs.mkdirSync(dir, { recursive: true });
                   const targetPath = path.join(dir, 'SKILL.md');
-                  fs.writeFileSync(targetPath, content, 'utf-8');
+                  replaceSkill(targetPath, content);
                   targets.push({ name: TARGET_NAMES[key], path: targetPath });
                 }
               }
@@ -380,7 +375,7 @@ export function skillCmd(wrap) {
               const dir = AGENT_SKILL_DIRS.hermes;
               fs.mkdirSync(dir, { recursive: true });
               const targetPath = path.join(dir, 'SKILL.md');
-              fs.writeFileSync(targetPath, content, 'utf-8');
+              replaceSkill(targetPath, content);
               targets.push({ name: TARGET_NAMES.hermes, path: targetPath });
             }
 
@@ -389,7 +384,7 @@ export function skillCmd(wrap) {
             }
 
             // Record install location so checkSkill knows where to look
-            recordSkillInstall(targets[0].path);
+            recordSkillInstall(targets.map(target => target.path), content);
 
             const installed = targets.reduce((acc, t) => { acc[t.name] = t.path; return acc; }, {});
             const summary = targets.length === 1
@@ -399,7 +394,7 @@ export function skillCmd(wrap) {
             const okOpts = {
               summary,
               breadcrumbs: [
-                { action: 'reinstall', cmd: 'jsn skill install', description: 'Re-download and reinstall to default target' },
+                { action: 'reinstall', cmd: 'jsn skill install', description: 'Replace recorded copies with the packaged skill' },
               ],
             };
 
@@ -407,7 +402,7 @@ export function skillCmd(wrap) {
               okOpts.notice = 'Installed to multiple agents. Restart or reload your agent to pick up the skill.';
             }
 
-            app.ok({ installed, from: SKILL_RAW_URL }, okOpts);
+            app.ok({ installed, from: SKILL_REPO_PATH }, okOpts);
           }),
         });
     },
@@ -416,7 +411,8 @@ export function skillCmd(wrap) {
       console.log('');
       console.log('Available subcommands:');
       console.log('  show       Show the bundled skill file');
-      console.log('  fetch      Download the latest skill from GitHub');
+      console.log('  fetch      Print the packaged skill (offline)');
+      console.log('  check      Show whether installed contents differ');
       console.log('  path       Show skill file locations');
       console.log('  install    Install skill file to agents directory');
       console.log('');

package/src/commands/tasks.js

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

package/src/commands/tickets.js

@@ -1,5 +1,7 @@
-import { formatRecordForDisplay, getStringField, buildQuerySuffix, resolveFieldsParam } from '../helpers.js';
-import { resolveRecord, resolveSysId } from '../resolve-record.js';
+import { enrichRelatedLists, relatedListOptions } from '../related-lists.js';
+import { formatRecordForDisplay, getStringField, buildQuerySuffix, resolveFieldsParam, buildRecordPayload, confirmDelete } from '../helpers.js';
+import { getRecord, listRecords, recordListParams, createRecord, updateRecord, deleteRecord, recordOptions } from '../records-engine.js';
+import { resolveSysId } from '../resolve-record.js';
 import { declareCapabilities } from '../capabilities.js';
 
 declareCapabilities('tickets', { mutationSubcommands: ['create', 'update', 'delete'] });
@@ -15,25 +17,20 @@ export function ticketsCmd(wrap) {
           command: 'list',
           aliases: ['ls'],
           describe: 'List tickets',
-          builder: (y) => y
+          builder: (y) => recordOptions(y)
             .option('query', { type: 'string', describe: 'Encoded query (e.g. "active=true^priority=1")' })
             .option('columns', { alias: ['c', 'fields'], type: 'string', describe: 'Comma-separated columns (e.g. "number,short_description,priority")' })
             .option('limit', { alias: 'l', type: 'number', default: 20, describe: 'Max records' })
             .option('offset', { alias: 'o', type: 'number', default: 0, describe: 'Offset' }),
           handler: wrap(async (argv, app) => {
             const columns = argv.columns ? argv.columns.split(',') : ['number', 'short_description', 'state', 'assigned_to'];
-            const params = new URLSearchParams();
-            params.set('sysparm_limit', String(argv.limit));
-            params.set('sysparm_offset', String(argv.offset));
-            params.set('sysparm_display_value', 'all');
             const fields = resolveFieldsParam(columns);
-            if (fields) params.set('sysparm_fields', fields);
             const q = argv.query ? argv.query + '^ORDERBYDESCsys_updated_on' : 'ORDERBYDESCsys_updated_on';
-            params.set('sysparm_query', q);
-            const records = await app.sdk.list('task', params);
-            const displayRecords = fields ? records.map(r => formatRecordForDisplay(r, columns)) : records;
+            const params = recordListParams({ limit: argv.limit, offset: argv.offset, fields, query: q });
+            const records = await listRecords(app.sdk, { table: 'task', params, displayValues: argv.displayValues });
+            const displayRecords = fields && !argv.displayValues ? records.map(r => formatRecordForDisplay(r, columns)) : records;
             const breadcrumbs = [
-              { action: 'create', cmd: 'jsn tickets create --data \'{...}\'', description: 'Create a new ticket' },
+              { action: 'create', cmd: 'jsn tickets create -f short_description=New ticket', description: 'Create a new ticket' },
             ];
             if (records.length === argv.limit) {
               breadcrumbs.push({
@@ -63,38 +60,50 @@ export function ticketsCmd(wrap) {
           command: 'show <number>',
           aliases: ['get'],
           describe: 'Show a ticket',
+          builder: y => relatedListOptions(recordOptions(y)),
           handler: wrap(async (argv, app) => {
-            const record = await resolveRecord(app.sdk, { table: 'task', identifier: argv.number, matchField: 'number', resource: 'Ticket' });
+            const record = await getRecord(app.sdk, { table: 'task', identifier: argv.number, identifierField: argv.identifierField, displayValues: argv.displayValues, matchField: 'number', resource: 'Ticket' });
+            await enrichRelatedLists(record, { table: 'task', argv, app });
             app.ok(record, { summary: `Ticket ${argv.number}` });
           }),
         })
         .command({
           command: 'create',
           describe: 'Create a new ticket',
-          builder: (y) => y.option('data', { type: 'string', demandOption: true, describe: 'JSON fields (e.g. \'{"state":"2","priority":"1"}\')' }),
+          builder: (y) => recordOptions(y, false)
+            .option('data', { type: 'string', describe: 'JSON fields' })
+            .option('data-file', { type: 'string', describe: 'Read JSON payload from file' })
+            .option('data-stdin', { type: 'boolean', describe: 'Read JSON payload from stdin' })
+            .option('field', { alias: 'f', type: 'string', array: true, describe: 'Set a field as name=value; repeatable' }),
           handler: wrap(async (argv, app) => {
-            const recordData = JSON.parse(argv.data);
-            const record = await app.sdk.create('task', recordData);
+            const recordData = buildRecordPayload(argv);
+            const record = await createRecord(app.sdk, { table: 'task', data: recordData });
             app.ok(record, { summary: `Created ticket ${getStringField(record, 'number')}` });
           }),
         })
         .command({
           command: 'update <number>',
           describe: 'Update a ticket',
-          builder: (y) => y.option('data', { type: 'string', demandOption: true, describe: 'JSON fields (e.g. \'{"state":"2","priority":"1"}\')' }),
+          builder: (y) => recordOptions(y, false)
+            .option('data', { type: 'string', describe: 'JSON fields' })
+            .option('data-file', { type: 'string', describe: 'Read JSON payload from file' })
+            .option('data-stdin', { type: 'boolean', describe: 'Read JSON payload from stdin' })
+            .option('field', { alias: 'f', type: 'string', array: true, describe: 'Set a field as name=value; repeatable' }),
           handler: wrap(async (argv, app) => {
-            const recordData = JSON.parse(argv.data);
-            const sysID = await resolveSysId(app.sdk, { table: 'task', identifier: argv.number, matchField: 'number', resource: 'Ticket' });
-            const updated = await app.sdk.update('task', sysID, recordData);
+            const recordData = buildRecordPayload(argv);
+            const sysID = await resolveSysId(app.sdk, { table: 'task', identifier: argv.number, identifierField: argv.identifierField, displayValues: argv.displayValues, matchField: 'number', resource: 'Ticket' });
+            const updated = await updateRecord(app.sdk, { table: 'task', record: { sys_id: sysID }, data: recordData });
             app.ok(updated, { summary: `Updated ticket ${argv.number}` });
           }),
         })
         .command({
           command: 'delete <number>',
           describe: 'Delete a ticket',
+          builder: y => recordOptions(y, false).option('force', { type: 'boolean', default: false, describe: 'Skip confirmation after approval' }),
           handler: wrap(async (argv, app) => {
-            const sysID = await resolveSysId(app.sdk, { table: 'task', identifier: argv.number, matchField: 'number', resource: 'Ticket' });
-            await app.sdk.delete('task', sysID);
+            await confirmDelete(app, argv, `Delete ticket ${argv.number}`);
+            const sysID = await resolveSysId(app.sdk, { table: 'task', identifier: argv.number, identifierField: argv.identifierField, displayValues: argv.displayValues, matchField: 'number', resource: 'Ticket' });
+            await deleteRecord(app.sdk, { table: 'task', record: { sys_id: sysID } });
             app.ok({ number: argv.number, message: 'Ticket deleted' }, { summary: `Deleted ticket ${argv.number}` });
           }),
         })

package/src/commands/uipolicies.js

@@ -1,28 +1,3 @@
-import { buildDevCmd } from './_generic.js';
-import { getStringField } from '../helpers.js';
+import { buildProfileCommand } from '../record-profiles.js';
 
-export const uipoliciesCmd = (wrap) => buildDevCmd('uipolicies', 'sys_ui_policy', ['uipolicy', 'up'],
-  ['short_description', 'table', 'sys_class_name', 'active'], wrap, {
-    singular: 'UI policy',
-    scopeValidation: true,
-    onShow: async (record, app) => {
-      const sysID = getStringField(record, 'sys_id') || '';
-      if (!sysID) return;
-      const mp = new URLSearchParams();
-      mp.set('sysparm_query', `ui_policy=${sysID}^ORDERBYorder`);
-      mp.set('sysparm_limit', '100'); mp.set('sysparm_display_value', 'all');
-      mp.set('sysparm_fields', 'name,table,field_name,read_only,mandatory,visible,sys_id');
-      const actions = await app.sdk.list('sys_ui_policy_action', mp);
-      if (actions.length > 0) {
-        console.log(`  Actions (${actions.length}):`);
-        for (const a of actions) {
-          const f = getStringField(a, 'field_name') || '(all fields)';
-          const flags = [];
-          if (getStringField(a, 'mandatory') === 'true') flags.push('mandatory');
-          if (getStringField(a, 'read_only') === 'true') flags.push('read-only');
-          if (getStringField(a, 'visible') === 'false') flags.push('hidden');
-          console.log(`    ${f}  ${flags.length ? `[${flags.join(', ')}]` : ''}`);
-        }
-      }
-    },
-  });
+export const uipoliciesCmd = wrap => buildProfileCommand('uipolicies', wrap);