@jacebenson/jsn 3.1.3 → 3.1.4

package/package.json

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

package/src/cli.js

@@ -38,9 +38,9 @@ import {
   privilegesCmd, securitytypesCmd, uxscriptsCmd, aliasesCmd,
   catalogscriptsCmd, cataloguipoliciesCmd,
   scriptactionsCmd, scheduledjobsCmd, asyncrulesCmd, triggersCmd,
-  workflowsCmd, decisiontablesCmd, assignmentsCmd,
+  decisiontablesCmd, assignmentsCmd,
   emailCmd,
-  restmessageCmd, restmethodsCmd, soapmessagesCmd, soapfunctionsCmd,
+  restmessageCmd, soapmessagesCmd,
   uimacrosCmd, uxlistsCmd, uxapplicabilityCmd,
 } from './commands/dev/_simple.js';
 import { flowsCmd } from './commands/dev/flows.js';
@@ -222,7 +222,6 @@ export function buildCLI() {
     .command(triggersCmd(wrap))
     // AUTOMATION — In Memory
     .command(rulesCmd(wrap))
-    .command(workflowsCmd(wrap))
     .command(decisiontablesCmd(wrap))
     .command(assignmentsCmd(wrap))
     // AUTOMATION — Inbound
@@ -230,9 +229,7 @@ export function buildCLI() {
     .command(emailCmd(wrap))
     // AUTOMATION — Outbound
     .command(restmessageCmd(wrap))
-    .command(restmethodsCmd(wrap))
     .command(soapmessagesCmd(wrap))
-    .command(soapfunctionsCmd(wrap))
     // ACCESS
     .command(aclsCmd(wrap))
     .command(b4rulesCmd(wrap))

package/src/commands/catalog.js

@@ -14,9 +14,34 @@ export function catalogCmd(wrap) {
           builder: (y) => y
             .option('name', { alias: 'n', type: 'string', demandOption: true })
             .option('short-description', { alias: 'd', type: 'string' })
-            .option('category', { alias: 'c', type: 'string' }),
+            .option('category', { alias: 'c', type: 'string' })
+            .option('variable', { alias: 'v', type: 'array', describe: 'Variable: "name:type:label"' })
+            .option('variables', { type: 'string', describe: 'JSON for submit_produce: {\"key\":\"value\"}' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
+
+            // submit_produce path
+            if (argv.variables) {
+              let varsObj;
+              try { varsObj = JSON.parse(argv.variables); } catch { throw new Error('--variables must be valid JSON'); }
+              let itemSysID = argv.name;
+              if (!/^[a-f0-9]{32}$/i.test(itemSysID)) {
+                const sp = new URLSearchParams();
+                sp.set('sysparm_query', `name=${itemSysID}`);
+                sp.set('sysparm_limit', '1');
+                sp.set('sysparm_fields', 'sys_id');
+                const items = await app.sdk.list('sc_cat_item', sp);
+                if (items.length === 0) throw new Error(`Not found: ${itemSysID}`);
+                itemSysID = items[0].sys_id?.value || items[0].sys_id;
+              }
+              const endpoint = `${app.sdk.baseURL}/api/sn_sc/servicecatalog/items/${itemSysID}/submit_produce`;
+              const result = await app.sdk.request(endpoint, { method: 'POST', body: JSON.stringify({ variables: varsObj }) });
+              const reqID = result?.result?.sys_id || result?.result?.number || '';
+              app.ok({ requested_item: reqID, item_id: itemSysID, variables: varsObj },
+                { summary: `Request: ${result?.result?.number || reqID}` });
+              return;
+            }
+
             let categoryID = '';
             if (argv.category) {
               const cp = new URLSearchParams();
@@ -34,7 +59,31 @@ export function catalogCmd(wrap) {
               active: true,
               type: 'item',
             });
-            app.ok(item, { summary: `Created: ${argv.name}` });
+            const itemID = item.sys_id?.value || item.sys_id;
+
+            // Create variables if --variable flag(s) provided
+            let varCount = 0;
+            if (argv.variable) {
+              for (const v of argv.variable) {
+                const parts = String(v).split(':');
+                if (parts.length >= 2) {
+                  const typeName = parts.length >= 2 ? parts[parts.length - 1] : '';
+                  const label = parts.length >= 3 ? parts[parts.length - 1] : parts[0];
+                  const sysName = parts[0].replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase();
+                  try {
+                    const typeMap = { string: '6', multilinetext: '2', select: '3', date: '4', datetime: '5', reference: '8', checkbox: '12', email: '11' };
+                    await app.sdk.create('item_option_new', {
+                      name: sysName, question_text: label, type: typeMap[typeName] || '6',
+                      order: (varCount + 1) * 100, cat_item: itemID, mandatory: true, active: true,
+                    });
+                    varCount++;
+                  } catch { /* non-fatal */ }
+                }
+              }
+            }
+
+            app.ok({ sys_id: itemID, name: argv.name, variables_created: varCount },
+              { summary: `Created: ${argv.name}${varCount ? ` (${varCount} variable(s))` : ''}` });
           }),
         })
         .command({
@@ -43,10 +92,11 @@ export function catalogCmd(wrap) {
           describe: 'List catalog items',
           builder: (y) => y
             .option('limit', { alias: 'l', type: 'number', default: 50 })
-            .option('category', { type: 'string' }),
+            .option('category', { type: 'string' })
+            .option('query', { type: 'string', describe: 'Encoded query (e.g. active=true)' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
-            const query = argv.category ? `category.titleLIKE${argv.category}` : '';
+            const query = argv.query || (argv.category ? `category.titleLIKE${argv.category}` : '');
 
             const picked = await interactiveList({
               app,
@@ -69,20 +119,27 @@ export function catalogCmd(wrap) {
               return;
             }
 
-            // Fallback — non-TTY
+            // Fallback — non-TTY / --json / --styled
             const p = new URLSearchParams();
             p.set('sysparm_query', query ? `${query}^ORDERBYname` : 'ORDERBYname');
             p.set('sysparm_limit', String(argv.limit));
             p.set('sysparm_display_value', 'all');
             p.set('sysparm_fields', 'name,short_description,category,active');
             const records = await app.sdk.list('sc_cat_item', p);
+            // Map reference fields to strings for styled/table renderer
+            const safe = records.map(r => ({
+              name: getStringField(r, 'name'),
+              short_description: getStringField(r, 'short_description'),
+              category: getStringField(r, 'category'),
+              active: getStringField(r, 'active'),
+            }));
             app.ok({
               table: 'sc_cat_item',
-              count: records.length,
+              count: safe.length,
               columns: ['name', 'short_description', 'category', 'active'],
-              records,
+              records: safe,
               context: { instance_url: app.getEffectiveInstance() },
-            }, { summary: `${records.length} catalog item(s)` });
+            }, { summary: `${safe.length} catalog item(s)` });
           }),
         })
         .command({
@@ -101,7 +158,6 @@ export function catalogCmd(wrap) {
               if (results.length === 0) throw new Error(`Not found: ${id}`);
               id = results[0].sys_id?.value || results[0].sys_id;
             }
-            const item = await app.sdk.get('sc_cat_item', id);
             await showItem(app, id);
           }),
         });
@@ -120,7 +176,6 @@ export function catalogCmd(wrap) {
 async function showItem(app, sysID) {
   const item = await app.sdk.get('sc_cat_item', sysID);
 
-  // Fetch variables
   const vp = new URLSearchParams();
   vp.set('sysparm_query', `cat_item=${sysID}^active=true`);
   vp.set('sysparm_limit', '100');
@@ -145,68 +200,40 @@ async function showItem(app, sysID) {
       standalone.push(entry);
     }
   }
-
   const totalVars = standalone.length + Array.from(setVars.values()).reduce((a, s) => a + s.variables.length, 0);
 
-  const lines = [];
-  lines.push(getStringField(item, 'name'));
-  if (getStringField(item, 'short_description')) lines.push(`  ${getStringField(item, 'short_description')}`);
-  lines.push(`  Category: ${getStringField(item, 'category') || '(none)'}`);
-  lines.push(`  Active: ${getStringField(item, 'active') || 'false'}`);
-  lines.push(`  URL: ${app.getEffectiveInstance()}/sc_cat_item.do?sys_id=${sysID}`);
-
-  // Flow / Workflow / Execution Plan
-  const flowName = getStringField(item, 'flow_designer_flow');
-  const flowID = item.flow_designer_flow?.value || '';
-  const wfName = getStringField(item, 'workflow');
-  const wfID = item.workflow?.value || '';
-  const planName = getStringField(item, 'delivery_plan') || getStringField(item, 'execution_plan');
-
-  if (flowID) {
-    if (flowName === flowID) {
-      try {
-        const flowRec = await app.sdk.get('sys_hub_flow', flowID);
-        lines.push(`  Flow: ${getStringField(flowRec, 'name') || flowID}`);
-      } catch {
-        lines.push(`  Flow: ${flowName}`);
-      }
-    } else {
-      lines.push(`  Flow: ${flowName}`);
-    }
-    lines.push(`    → jsn flows show ${flowID}`);
-  } else if (wfName) {
-    lines.push(`  Workflow: ${wfName}`);
-    if (wfID) lines.push(`    → jsn workflows show ${wfID}`);
-  } else if (planName) {
-    const planID = item.delivery_plan?.value || item.execution_plan?.value || '';
-    if (planName === planID && planID) {
-      try {
-        const planRec = await app.sdk.get('delivery_plan', planID);
-        const realName = getStringField(planRec, 'name') || getStringField(planRec, 'short_description') || planID;
-        lines.push(`  Execution Plan: ${realName}`);
-        lines.push(`    → jsn records get --table delivery_plan --sys-id ${planID}`);
-      } catch {
-        lines.push(`  Execution Plan: ${planName}`);
-      }
-    } else {
-      lines.push(`  Execution Plan: ${planName}`);
-    }
-  }
-
-  if (totalVars > 0) {
-    lines.push(`  Variables (${totalVars}):`);
-    for (const v of standalone) {
-      const flags = String(v.mandatory) === 'true' ? ' [required]' : '';
-      lines.push(`    ${v.question_text || v.name}  ${v.type || ''}${flags}`);
-    }
-    for (const [_, sd] of setVars) {
-      lines.push(`    [${sd.name}]`);
-      for (const v of sd.variables) {
-        const flags = String(v.mandatory) === 'true' ? ' [required]' : '';
-        lines.push(`      ${v.question_text || v.name}  ${v.type || ''}${flags}`);
-      }
-    }
+  // Resolve flow name
+  let flowName = '', flowCmd = '';
+  const flowVal = item.flow_designer_flow;
+  if (flowVal?.value) {
+    const fn = getStringField(item, 'flow_designer_flow');
+    if (fn === flowVal.value) {
+      try { const fr = await app.sdk.get('sys_hub_flow', flowVal.value); flowName = getStringField(fr, 'name') || ''; } catch { flowName = fn; }
+    } else { flowName = fn; }
+    flowCmd = `jsn flows show ${flowVal.value}`;
   }
+  const wfName = getStringField(item, 'workflow') || '';
+  const wfID = item.workflow?.value || '';
+  const planName = getStringField(item, 'delivery_plan') || getStringField(item, 'execution_plan') || '';
+  const planID = item.delivery_plan?.value || item.execution_plan?.value || '';
 
-  console.log(lines.join('\n'));
+  app.ok({
+    name: getStringField(item, 'name'),
+    short_description: getStringField(item, 'short_description'),
+    category: getStringField(item, 'category'),
+    active: getStringField(item, 'active'),
+    url: `${app.getEffectiveInstance()}/sc_cat_item.do?sys_id=${sysID}`,
+    flow: flowName || undefined,
+    flow_cmd: flowCmd || undefined,
+    workflow: wfName || undefined,
+    workflow_cmd: (wfName && wfID) ? `jsn workflows show ${wfID}` : undefined,
+    execution_plan: planName || undefined,
+    variables: totalVars > 0 ? {
+      count: totalVars,
+      standalone: standalone.map(v => ({ label: v.question_text || v.name, type: v.type, mandatory: String(v.mandatory) === 'true' })),
+      sets: Array.from(setVars.values()).map(s => ({ name: s.name, variables: s.variables.map(v => ({ label: v.question_text || v.name, type: v.type, mandatory: String(v.mandatory) === 'true' })) })),
+    } : undefined,
+  }, {
+    summary: `${getStringField(item, 'name')} — ${totalVars} variable(s)`,
+  });
 }

package/src/commands/dev/_generic.js

@@ -81,6 +81,7 @@ export function buildDevCmd(name, table, aliases, defaultColumns, wrap, opts = {
   const readOnly = opts.readOnly || false;
   const scopeValidation = opts.scopeValidation || false;
   const extraQuery = opts.extraQuery || '';
+  const formatLabel = opts.formatLabel || null;
   const showSummary = opts.showSummary || ((record, id) => `${singular.charAt(0).toUpperCase() + singular.slice(1)}: ${getStringField(record, 'name') || id}`);
   const showBreadcrumbs = opts.showBreadcrumbs || ((record, id) => {
     const crumbs = [

package/src/commands/dev/_simple.js

@@ -101,22 +101,20 @@ export const catalogscriptsCmd = (wrap) => buildDevCmd('catalogscripts', 'catalo
 // ── Automation: Async ──
 export const scriptactionsCmd = (wrap) => buildDevCmd('scriptactions', 'sysevent_script_action', ['scriptaction'], ['name', 'active', 'sys_scope'], wrap, { singular: 'script action', scopeValidation: true });
 export const scheduledjobsCmd = (wrap) => buildDevCmd('scheduledjobs', 'sysauto_script', ['scheduledjob'], ['name', 'active', 'run_type', 'sys_scope'], wrap, { singular: 'scheduled job', scopeValidation: true });
-export const asyncrulesCmd = (wrap) => buildDevCmd('asyncrules', 'sys_script', ['asyncrule'], ['name', 'collection', 'active', 'order', 'sys_scope'], wrap, { singular: 'async business rule', scopeValidation: true, extraQuery: 'order>=1000' });
+export const asyncrulesCmd = (wrap) => buildDevCmd('asyncrules', 'sys_script', ['asyncrule'], ['name', 'collection', 'active', 'order', 'sys_scope'], wrap, { singular: 'async business rule', scopeValidation: true, extraQuery: 'when=async' });
 export const triggersCmd = (wrap) => buildDevCmd('triggers', 'sysevent_register', ['trigger'], ['name', 'event_name', 'active', 'sys_scope'], wrap, { singular: 'event trigger', scopeValidation: true });
 
 // ── Automation: In Memory ──
-export const workflowsCmd = (wrap) => buildDevCmd('workflows', 'wf_workflow', ['workflow'], ['name', 'table', 'active', 'sys_scope'], wrap, { singular: 'workflow', scopeValidation: true, readOnly: true });
-export const decisiontablesCmd = (wrap) => buildDevCmd('decisiontables', 'sys_decision', ['decisiontable'], ['name', 'active', 'sys_scope'], wrap, { singular: 'decision table', scopeValidation: true, readOnly: true });
+export const decisiontablesCmd = (wrap) => buildDevCmd('decisiontables', 'sys_ws_definition', ['decisiontable'], ['name', 'active', 'sys_scope'], wrap, { singular: 'decision table', scopeValidation: true, readOnly: true });
 export const assignmentsCmd = (wrap) => buildDevCmd('assignments', 'sysrule_assignment', ['assignment'], ['name', 'active', 'sys_scope'], wrap, { singular: 'assignment rule', scopeValidation: true, readOnly: true });
 
 // ── Automation: Inbound ──
-export const emailCmd = (wrap) => buildDevCmd('email', 'sysevent_email_action', ['emails'], ['name', 'active', 'event_name', 'sys_scope'], wrap, { singular: 'inbound email action', scopeValidation: true });
+export const emailCmd = (wrap) => buildDevCmd('email', 'sysevent_in_email_action', ['emails'], ['name', 'active', 'type', 'sys_scope'], wrap, { singular: 'inbound email action', scopeValidation: true });
 
 // ── Automation: Outbound ──
-export const restmessageCmd = (wrap) => buildDevCmd('restmessage', 'sys_rest_message', ['rm', 'restmsg'], ['name', 'endpoint', 'active', 'sys_scope'], wrap, { singular: 'REST message', scopeValidation: true });
+export { restmessageCmd } from './restmessage.js';
 export const restmethodsCmd = (wrap) => buildDevCmd('restmethods', 'sys_rest_message_fn', ['restmethod'], ['name', 'http_method', 'active', 'sys_scope'], wrap, { singular: 'REST method', scopeValidation: true });
-export const soapmessagesCmd = (wrap) => buildDevCmd('soapmessages', 'sys_soap_message', ['soapmsg'], ['name', 'active', 'sys_scope'], wrap, { singular: 'SOAP message', scopeValidation: true });
-export const soapfunctionsCmd = (wrap) => buildDevCmd('soapfunctions', 'sys_soap_message_function', ['soapfunc'], ['name', 'active', 'sys_scope'], wrap, { singular: 'SOAP function', scopeValidation: true });
+export { soapmessagesCmd } from './soapmessages.js';
 
 // ── UX: Core UI ──
 export const uimacrosCmd = (wrap) => buildDevCmd('uimacros', 'sys_ui_macro', ['uimacro'], ['name', 'active', 'sys_scope'], wrap, { singular: 'UI macro', scopeValidation: true });

package/src/commands/dev/restmessage.js

@@ -0,0 +1,32 @@
+import { buildDevCmd } from './_generic.js';
+import { getStringField } from '../../helpers.js';
+
+export const restmessageCmd = (wrap) => buildDevCmd('restmessage', 'sys_rest_message', ['rm', 'restmsg'],
+  ['name', 'endpoint', 'active', 'sys_scope'], wrap, {
+    singular: 'REST message',
+    scopeValidation: true,
+    onShow: async (record, app) => {
+      const sysID = getStringField(record, 'sys_id') || '';
+      if (!sysID) return;
+
+      // Fetch related methods
+      const mp = new URLSearchParams();
+      mp.set('sysparm_query', `rest_message=${sysID}^ORDERBYorder`);
+      mp.set('sysparm_limit', '100');
+      mp.set('sysparm_display_value', 'all');
+      mp.set('sysparm_fields', 'name,http_method,rest_endpoint,order,sys_id');
+      const methods = await app.sdk.list('sys_rest_message_fn', mp);
+
+      if (methods.length > 0) {
+        console.log(`  Methods (${methods.length}):`);
+        for (const m of methods) {
+          const name = getStringField(m, 'name') || getStringField(m, 'http_method') || '';
+          const method = getStringField(m, 'http_method') || '';
+          const path = getStringField(m, 'rest_endpoint') || '';
+          const mid = getStringField(m, 'sys_id') || '';
+          console.log(`    ${method} ${path}  (${name})`);
+          console.log(`      → jsn records get --table sys_rest_message_fn --sys-id ${mid}`);
+        }
+      }
+    },
+  });

package/src/commands/dev/soapmessages.js

@@ -0,0 +1,30 @@
+import { buildDevCmd } from './_generic.js';
+import { getStringField } from '../../helpers.js';
+
+export const soapmessagesCmd = (wrap) => buildDevCmd('soapmessages', 'sys_soap_message', ['soapmsg'],
+  ['name', 'active', 'sys_scope'], wrap, {
+    singular: 'SOAP message',
+    scopeValidation: true,
+    onShow: async (record, app) => {
+      const sysID = getStringField(record, 'sys_id') || '';
+      if (!sysID) return;
+
+      // Fetch related functions
+      const mp = new URLSearchParams();
+      mp.set('sysparm_query', `soap_message=${sysID}^ORDERBYorder`);
+      mp.set('sysparm_limit', '100');
+      mp.set('sysparm_display_value', 'all');
+      mp.set('sysparm_fields', 'name,order,sys_id');
+      const funcs = await app.sdk.list('sys_soap_message_function', mp);
+
+      if (funcs.length > 0) {
+        console.log(`  Functions (${funcs.length}):`);
+        for (const f of funcs) {
+          const name = getStringField(f, 'name') || '';
+          const fid = getStringField(f, 'sys_id') || '';
+          console.log(`    ${name}`);
+          console.log(`      → jsn records get --table sys_soap_message_function --sys-id ${fid}`);
+        }
+      }
+    },
+  });

package/src/help.js

@@ -36,7 +36,6 @@ const AUTOMATION_COMMANDS = [
 
   { divider: '── In Memory ──' },
   { name: 'rules', alias: 'br', desc: 'Business rules (create, update, delete)' },
-  { name: 'workflows', desc: 'Workflow definitions' },
   { name: 'decisiontables', desc: 'Decision tables' },
   { name: 'assignments', desc: 'Assignment rules' },
 
@@ -46,9 +45,7 @@ const AUTOMATION_COMMANDS = [
 
   { divider: '── Outbound ──' },
   { name: 'restmessage', alias: 'rm', desc: 'REST Messages (sys_rest_message)' },
-  { name: 'restmethods', desc: 'REST Message methods (sys_rest_message_fn)' },
   { name: 'soapmessages', desc: 'SOAP Messages' },
-  { name: 'soapfunctions', desc: 'SOAP Message functions' },
 ];
 
 const ACCESS_COMMANDS = [

package/src/output.js

@@ -281,7 +281,7 @@ export class OutputWriter {
         const width = colWidths[col] || 20;
 
         if (j === 0 && instanceURL && table && row.sys_id) {
-          const url = `${instanceURL}/${table}.do?sys_id=${row.sys_id}`;
+          const url = getTableURL(instanceURL, table, row.sys_id);
           val = hyperlink(val, url);
         }
 
@@ -291,7 +291,7 @@ export class OutputWriter {
           display = visible.slice(0, width - 3) + '...';
           if (val !== visible) {
             if (j === 0 && instanceURL && table && row.sys_id) {
-              const url = `${instanceURL}/${table}.do?sys_id=${row.sys_id}`;
+              const url = getTableURL(instanceURL, table, row.sys_id);
               display = hyperlink(display, url);
             }
           }
@@ -417,7 +417,7 @@ export class OutputWriter {
       const sysID = getDisplayValue(data.sys_id);
       if (sysID) {
         const urlTable = table.toLowerCase().replace(/\s+/g, '_');
-        const recordURL = `${instanceURL}/${urlTable}.do?sys_id=${sysID}`;
+        const recordURL = getTableURL(instanceURL, urlTable, sysID);
         this.writer.write(`Link:  ${recordURL}\n\n`);
       }
     }
@@ -453,6 +453,18 @@ function detectRecord(data) {
   return { isRecord: hasSysID && (hasSysClass || tableName), tableName };
 }
 
+export function getTableURL(instance, table, sysID) {
+  const mapped = {
+    sys_decision: `now/workflow-studio/builder?table=sys_decision&sysId=${sysID}`,
+    sys_rest_message: `nav_to.do?uri=sys_rest_message.do?sys_id=${sysID}`,
+    sysevent_email_action: `nav_to.do?uri=sysevent_email_action.do?sys_id=${sysID}`,
+    sysevent_in_email_action: `nav_to.do?uri=sysevent_in_email_action.do?sys_id=${sysID}`,
+    soap_message: `nav_to.do?uri=soap_message.do?sys_id=${sysID}`,
+  };
+  const path = mapped[table] || `${table}.do?sys_id=${sysID}`;
+  return `${instance}/${path}`;
+}
+
 export function getDisplayValue(val) {
   if (val == null) return '';
   if (typeof val === 'string') return val;

package/src/paginated-search.js

@@ -4,16 +4,10 @@
 
 import { createPrompt, useState, useKeypress, usePagination, useEffect, useRef } from '@inquirer/core';
 import { isEnterKey, isUpKey, isDownKey } from '@inquirer/core';
-import { appendFileSync } from 'fs';
 
 export const paginatedSearch = createPrompt((config, done) => {
   const { message, pageSize = 10, totalCount = 0, source } = config;
 
-  // ── DEBUG ──
-  const DBG = '/home/jace/workspace/holly/sn-jsn-fork/debug.log';
-  const log = (msg) => appendFileSync(DBG, `${new Date().toISOString()} ${msg}\n`);
-  log(`START totalCount=${totalCount}`);
-
   const [status, setStatus] = useState('loading');
   const [searchTerm, setSearchTerm] = useState('');
   const [choices, setChoices] = useState([]);
@@ -36,12 +30,10 @@ export const paginatedSearch = createPrompt((config, done) => {
   useEffect(() => {
     const controller = new AbortController();
     setStatus('loading');
-    log(`EFFECT-INIT searchTerm="${searchTerm}"`);
 
     const load = async () => {
       try {
         const items = await source(searchTerm || undefined, 0, { signal: controller.signal });
-        log(`INIT-LOAD got ${items.length} items`);
         if (!controller.signal.aborted) {
           choicesRef.current = items;
           loadedRef.current = items.length;
@@ -52,7 +44,6 @@ export const paginatedSearch = createPrompt((config, done) => {
           setStatus('done');
         }
       } catch (err) {
-        log(`INIT-LOAD error: ${err.message}`);
         if (!controller.signal.aborted) {
           setStatus('done');
           setChoices([]);
@@ -66,16 +57,10 @@ export const paginatedSearch = createPrompt((config, done) => {
 
   // Load more when scrolling past end
   async function loadMore() {
-    log(`loadMore check: loaded=${loadedRef.current} total=${totalCountRef.current} searchMode=${searchModeRef.current}`);
-    if (loadedRef.current >= totalCountRef.current || searchModeRef.current) {
-      log(`loadMore SKIPPED`);
-      return;
-    }
+    if (loadedRef.current >= totalCountRef.current || searchModeRef.current) return;
     setStatus('loading');
-    log(`loadMore calling source offset=${loadedRef.current}`);
     try {
       const newItems = await source('', loadedRef.current, { signal: new AbortController().signal });
-      log(`loadMore got ${newItems.length} items`);
       const updated = choicesRef.current.concat(newItems);
       choicesRef.current = updated;
       loadedRef.current = updated.length;
@@ -166,7 +151,6 @@ export const paginatedSearch = createPrompt((config, done) => {
         activeRef.current++;
         setActive(activeRef.current);
       } else if (!searchModeRef.current && loadedRef.current < totalCountRef.current) {
-        log(`DOWN at end: active=${activeRef.current} len=${choicesRef.current.length} loaded=${loadedRef.current} total=${totalCountRef.current}`);
         loadMore().then(() => {
           activeRef.current++;
           setActive(activeRef.current);

package/src/sdk.js

@@ -139,10 +139,6 @@ export class SDKClient {
   async list(table, params = {}) {
     const query = new URLSearchParams(params).toString();
     const endpoint = `${this.baseURL}/api/now/table/${table}${query ? '?' + query : ''}`;
-    // Debug: log paginated queries
-    if (params.sysparm_offset) {
-      process.stderr.write(`[SDK list] offset=${params.sysparm_offset} limit=${params.sysparm_limit} table=${table}\n`);
-    }
     const result = await this.request(endpoint, { method: 'GET' });
     return result?.result || [];
   }