@jacebenson/jsn 1.0.7 → 2.0.1

package/src/commands/skill.js

@@ -0,0 +1,144 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const SKILL_REPO_PATH = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..', '..', 'skills', 'servicenow', 'SKILL.md'
+);
+
+const SKILL_RAW_URL = 'https://raw.githubusercontent.com/jacebenson/jsn/nodejs/skills/servicenow/SKILL.md';
+
+function readBundledSkill() {
+  try {
+    return fs.readFileSync(SKILL_REPO_PATH, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+export async function checkSkill() {
+  const bundled = readBundledSkill();
+  if (!bundled) return { current: false, error: 'Skill file not found in package' };
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10000);
+    const res = await fetch(SKILL_RAW_URL, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return { current: false, error: `GitHub returned ${res.status}` };
+    const upstream = await res.text();
+    const current = bundled === upstream;
+    return {
+      current,
+      bundled_lines: bundled.split('\n').length,
+      upstream_lines: upstream.split('\n').length,
+      error: current ? null : 'Bundled skill is outdated — run "jsn skill install" to update',
+    };
+  } catch {
+    return { current: false, error: 'Could not check — GitHub unreachable' };
+  }
+}
+
+export function skillCmd(wrap) {
+  return {
+    command: 'skill',
+    describe: 'Manage the jsn AI agent skill file (for Hermes, Claude Code, Cursor, etc.)',
+    builder: (y) => {
+      return y
+        .command({
+          command: 'show',
+          describe: 'Show the bundled skill file content',
+          handler: wrap(async (_argv, app) => {
+            const content = readBundledSkill();
+            if (!content) {
+              throw new Error('Skill file not found in package (expected at skills/servicenow/SKILL.md)');
+            }
+            app.ok({
+              content,
+              bundled: SKILL_REPO_PATH,
+            }, {
+              summary: 'jsn AI agent skill file (bundled)',
+            });
+          }),
+        })
+        .command({
+          command: 'check',
+          describe: 'Check if the bundled skill file is up to date with GitHub',
+          handler: wrap(async (_argv, app) => {
+            const result = await checkSkill();
+            if (result.error && !result.current) {
+              app.ok(result, { summary: result.error });
+            } else if (result.current) {
+              app.ok(result, { summary: `✓ Skill is current (${result.bundled_lines} lines)` });
+            } else {
+              app.ok(result, { summary: `⚠ Skill is outdated (bundled ${result.bundled_lines} lines vs upstream ${result.upstream_lines} lines) — run "jsn skill install" to update` });
+            }
+          }),
+        })
+        .command({
+          command: 'fetch',
+          describe: 'Download the latest skill file from GitHub to stdout',
+          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();
+            process.stdout.write(content);
+          }),
+        })
+        .command({
+          command: 'path',
+          describe: 'Show skill file locations and install targets',
+          handler: wrap(async (_argv, app) => {
+            const hermesDir = path.join(os.homedir(), '.hermes', 'skills', 'servicenow');
+            const hermesPath = path.join(hermesDir, 'SKILL.md');
+            app.ok({
+              bundled: SKILL_REPO_PATH,
+              hermes: hermesPath,
+              raw_url: SKILL_RAW_URL,
+            }, {
+              summary: 'Skill file locations',
+              breadcrumbs: [
+                { action: 'view', cmd: 'jsn skill show', description: 'Show bundled skill content' },
+                { action: 'fetch', cmd: 'jsn skill fetch', description: 'Download latest from GitHub' },
+                { action: 'install', cmd: 'jsn skill install', description: 'Download + save to Hermes' },
+              ],
+            });
+          }),
+        })
+        .command({
+          command: 'install [dir]',
+          describe: 'Download and save the latest skill file',
+          builder: (y) => y
+            .positional('dir', {
+              type: 'string',
+              describe: 'Target directory (default: ~/.hermes/skills/servicenow/)',
+            }),
+          handler: wrap(async (argv, app) => {
+            const targetDir = argv.dir || path.join(os.homedir(), '.hermes', 'skills', 'servicenow');
+            const targetPath = path.join(targetDir, 'SKILL.md');
+
+            fs.mkdirSync(targetDir, { recursive: true });
+
+            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();
+
+            fs.writeFileSync(targetPath, content, 'utf-8');
+
+            app.ok({
+              installed: targetPath,
+              from: SKILL_RAW_URL,
+            }, {
+              summary: `Skill installed to ${targetPath}`,
+              breadcrumbs: [
+                { action: 'verify', cmd: `head -30 ${targetPath}`, description: 'Verify the installed skill' },
+                { action: 'reinstall', cmd: 'jsn skill install', description: 'Re-download and reinstall' },
+              ],
+            });
+          }),
+        });
+    },
+    handler: () => {},
+  };
+}

package/src/commands/tasks.js

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

package/src/commands/tickets.js

@@ -0,0 +1,121 @@
+import { formatRecordForDisplay, getStringField, buildQuerySuffix } from '../helpers.js';
+
+export function ticketsCmd(wrap) {
+  return {
+    command: 'tickets [subcommand]',
+    aliases: ['ticket'],
+    describe: 'Query generic tickets (e.g. "tickets list --query active=true")',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List tickets',
+          builder: (y) => 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');
+            params.set('sysparm_fields', ['sys_id', ...columns].join(','));
+            const q = argv.query ? argv.query + '^ORDERBYDESCsys_updated_on' : 'ORDERBYDESCsys_updated_on';
+            params.set('sysparm_query', q);
+            const records = await app.sdk.list('ticket', params);
+            const displayRecords = records.map(r => formatRecordForDisplay(r, columns));
+            const breadcrumbs = [
+              { action: 'create', cmd: 'jsn tickets create --data \'{...}\'', description: 'Create a new ticket' },
+            ];
+            if (records.length === argv.limit) {
+              breadcrumbs.push({
+                action: 'next',
+                cmd: `jsn tickets list --limit ${argv.limit} --offset ${argv.offset + argv.limit}${buildQuerySuffix(argv.query)}`,
+                description: `Next page`,
+              });
+            }
+            if (argv.offset > 0) {
+              breadcrumbs.push({
+                action: 'prev',
+                cmd: `jsn tickets list --limit ${argv.limit} --offset ${Math.max(0, argv.offset - argv.limit)}${buildQuerySuffix(argv.query)}`,
+                description: 'Previous page',
+              });
+            }
+            app.ok({
+              table: 'ticket',
+              count: records.length,
+              columns,
+              records: displayRecords,
+              pagination: { limit: argv.limit, offset: argv.offset },
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} ticket(s)`, breadcrumbs });
+          }),
+        })
+        .command({
+          command: 'show <number>',
+          aliases: ['get'],
+          describe: 'Show a ticket',
+          handler: wrap(async (argv, app) => {
+            const params = new URLSearchParams();
+            params.set('sysparm_query', `number=${argv.number}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_display_value', 'all');
+            const records = await app.sdk.list('ticket', params);
+            if (records.length === 0) {
+              throw new Error(`Ticket not found: ${argv.number}`);
+            }
+            app.ok(records[0], { 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"}\')' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = JSON.parse(argv.data);
+            const record = await app.sdk.create('ticket', 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"}\')' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = JSON.parse(argv.data);
+            const findParams = new URLSearchParams();
+            findParams.set('sysparm_query', `number=${argv.number}`);
+            findParams.set('sysparm_limit', '1');
+            const records = await app.sdk.list('ticket', findParams);
+            if (records.length === 0) {
+              throw new Error(`Ticket not found: ${argv.number}`);
+            }
+            const sysID = getStringField(records[0], 'sys_id');
+            const updated = await app.sdk.update('ticket', sysID, recordData);
+            app.ok(updated, { summary: `Updated ticket ${argv.number}` });
+          }),
+        })
+        .command({
+          command: 'delete <number>',
+          describe: 'Delete a ticket',
+          handler: wrap(async (argv, app) => {
+            const findParams = new URLSearchParams();
+            findParams.set('sysparm_query', `number=${argv.number}`);
+            findParams.set('sysparm_limit', '1');
+            const records = await app.sdk.list('ticket', findParams);
+            if (records.length === 0) {
+              throw new Error(`Ticket not found: ${argv.number}`);
+            }
+            const sysID = getStringField(records[0], 'sys_id');
+            await app.sdk.delete('ticket', sysID);
+            app.ok({ number: argv.number, message: 'Ticket deleted' }, { summary: `Deleted ticket ${argv.number}` });
+          }),
+        })
+
+    },
+    handler: () => {},
+  };
+}

package/src/commands/users.js

@@ -0,0 +1,144 @@
+import { formatRecordForDisplay, getStringField, interactiveList } from '../helpers.js';
+
+export function usersCmd(wrap) {
+  return {
+    command: 'users [subcommand]',
+    aliases: ['user'],
+    describe: 'Manage ServiceNow users',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          aliases: ['ls'],
+          describe: 'List users',
+          builder: (y) => y
+            .option('query', { type: 'string', describe: 'Encoded query (e.g. "nameLIKEincident" or "active=true")' })
+            .option('columns', { alias: ['c', 'fields'], type: 'string', describe: 'Comma-separated columns (e.g. "number,short_description")' })
+            .option('limit', { alias: 'l', type: 'number', default: 20, describe: 'Max records' }),
+          handler: wrap(async (argv, app) => {
+            const columns = argv.columns ? argv.columns.split(',') : ['user_name', 'name', 'email', 'active'];
+            const query = argv.query || '';
+
+            const picked = await interactiveList({
+              app, table: 'sys_user', singular: 'user', columns, limit: argv.limit, query, labelField: 'user_name',
+              formatLabel: r => `${getStringField(r, 'user_name')} (${getStringField(r, 'name') || '-'})`,
+            });
+            if (picked) {
+              picked._context = { instance_url: app.getEffectiveInstance(), table: 'sys_user' };
+              return app.ok(picked, { summary: `User: ${getStringField(picked, 'user_name')}` });
+            }
+
+            const params = new URLSearchParams();
+            params.set('sysparm_limit', String(argv.limit));
+            params.set('sysparm_display_value', 'all');
+            params.set('sysparm_fields', ['sys_id', ...columns].join(','));
+            if (argv.query) params.set('sysparm_query', argv.query);
+            const records = await app.sdk.list('sys_user', params);
+            app.ok({
+              table: 'sys_user',
+              count: records.length,
+              columns,
+              records: records.map(r => formatRecordForDisplay(r, columns)),
+              context: { instance_url: app.getEffectiveInstance() },
+            }, { summary: `${records.length} user(s)` });
+          }),
+        })
+        .command({
+          command: 'show <identifier>',
+          aliases: ['get'],
+          describe: 'Show a user by user_name or sys_id',
+          handler: wrap(async (argv, app) => {
+            const id = argv.identifier;
+            const isSysID = id.length === 32 && /^[0-9a-fA-F]+$/.test(id);
+            const params = new URLSearchParams();
+            params.set('sysparm_query', isSysID ? `sys_id=${id}` : `user_name=${id}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_display_value', 'all');
+            const records = await app.sdk.list('sys_user', params);
+            if (records.length === 0) {
+              throw new Error(`User not found: ${id}`);
+            }
+            app.ok(records[0], { summary: `User ${id}` });
+          }),
+        })
+        .command({
+          command: 'create',
+          describe: 'Create a new user',
+          builder: (y) => y
+            .option('username', { alias: 'u', type: 'string', describe: 'Username (e.g. john.doe)' })
+            .option('name', { alias: 'n', type: 'string', describe: 'Full name (e.g. John Doe)' })
+            .option('email', { alias: 'e', type: 'string', describe: 'Email address' })
+            .option('data', { type: 'string', describe: 'JSON data for additional fields' }),
+          handler: wrap(async (argv, app) => {
+            const recordData = {};
+            if (argv.data) {
+              Object.assign(recordData, JSON.parse(argv.data));
+            }
+            if (argv.username) recordData.user_name = argv.username;
+            if (argv.name) recordData.name = argv.name;
+            if (argv.email) recordData.email = argv.email;
+            if (!recordData.user_name) {
+              throw new Error('user_name is required (use --username or --data)');
+            }
+            const record = await app.sdk.create('sys_user', recordData);
+            app.ok(record, {
+              summary: `Created user ${getStringField(record, 'user_name')}`,
+              breadcrumbs: [
+                { action: 'view', cmd: `jsn users show ${getStringField(record, 'user_name')}`, description: `View the new user` },
+              ],
+            });
+          }),
+        })
+        .command({
+          command: 'update <identifier>',
+          describe: 'Update a user by user_name or sys_id',
+          builder: (y) => y
+            .option('data', { type: 'string', demandOption: true, describe: 'JSON data to update' }),
+          handler: wrap(async (argv, app) => {
+            const id = argv.identifier;
+            const recordData = JSON.parse(argv.data);
+            const isSysID = id.length === 32 && /^[0-9a-fA-F]+$/.test(id);
+            const params = new URLSearchParams();
+            params.set('sysparm_query', isSysID ? `sys_id=${id}` : `user_name=${id}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_display_value', 'all');
+            params.set('sysparm_fields', 'sys_id');
+            const records = await app.sdk.list('sys_user', params);
+            if (records.length === 0) {
+              throw new Error(`User not found: ${id}`);
+            }
+            const sysID = getStringField(records[0], 'sys_id');
+            const updated = await app.sdk.update('sys_user', sysID, recordData);
+            app.ok(updated, {
+              summary: `Updated user ${id}`,
+              breadcrumbs: [
+                { action: 'view', cmd: `jsn users show ${id}`, description: `View the updated user` },
+              ],
+            });
+          }),
+        })
+        .command({
+          command: 'delete <identifier>',
+          describe: 'Delete a user by user_name or sys_id',
+          handler: wrap(async (argv, app) => {
+            const id = argv.identifier;
+            const isSysID = id.length === 32 && /^[0-9a-fA-F]+$/.test(id);
+            const params = new URLSearchParams();
+            params.set('sysparm_query', isSysID ? `sys_id=${id}` : `user_name=${id}`);
+            params.set('sysparm_limit', '1');
+            params.set('sysparm_fields', 'sys_id');
+            const records = await app.sdk.list('sys_user', params);
+            if (records.length === 0) {
+              throw new Error(`User not found: ${id}`);
+            }
+            const sysID = getStringField(records[0], 'sys_id');
+            await app.sdk.delete('sys_user', sysID);
+            app.ok({ identifier: id, message: 'User deleted' }, {
+              summary: `Deleted user ${id}`,
+            });
+          }),
+        });
+    },
+    handler: () => {},
+  };
+}

package/src/commands/version.js

@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const NPM_PKG = '@jacebenson/jsn';
+const NPM_REGISTRY = `https://registry.npmjs.org/${NPM_PKG}/latest`;
+
+function getVersion() {
+  try {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path.join(__dirname, '..', '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version;
+  } catch {
+    return '0.0.0';
+  }
+}
+
+async function checkLatest() {
+  try {
+    const res = await fetch(NPM_REGISTRY);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+
+export function versionCmd(wrap) {
+  return {
+    command: 'version',
+    describe: 'Show version information',
+    builder: (y) => y
+      .option('check', {
+        alias: 'c',
+        type: 'boolean',
+        describe: 'Check npm registry for newer version',
+      }),
+    handler: wrap(async (argv, app) => {
+      const version = getVersion();
+
+      if (argv.check) {
+        const latest = await checkLatest();
+        if (!latest) {
+          app.ok({ version }, {
+            summary: `jsn ${version} (could not reach npm registry to check for updates)`,
+            notice: `Run \`npm view ${NPM_PKG}\` directly to check manually`,
+          });
+          return;
+        }
+
+        const isUpToDate = version === latest;
+
+        if (isUpToDate) {
+          app.ok({
+            version,
+            latest,
+            upToDate: true,
+          }, {
+            summary: `jsn ${version} — up to date`,
+          });
+        } else {
+          app.ok({
+            version,
+            latest,
+            upToDate: false,
+            installCmd: `npm install -g ${NPM_PKG}`,
+          }, {
+            summary: `jsn ${version} — newer version ${latest} available`,
+            breadcrumbs: [
+              { action: 'update', cmd: `npm install -g ${NPM_PKG}`, description: `Update jsn from ${version} to ${latest}` },
+            ],
+          });
+        }
+      } else {
+        app.ok({ version }, { summary: `jsn ${version}` });
+      }
+    }),
+  };
+}

package/src/config.js

@@ -0,0 +1,154 @@
+// Layered configuration: flags > env > local > global > defaults
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const APP_NAME = 'servicenow';
+
+export function globalConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return path.join(xdg, APP_NAME);
+  return path.join(os.homedir(), '.config', APP_NAME);
+}
+
+export function globalConfigPath() {
+  return path.join(globalConfigDir(), 'config.json');
+}
+
+export function localConfigPath() {
+  return path.join(process.cwd(), `.${APP_NAME}`, 'config.json');
+}
+
+export function cacheDir() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  if (xdg) return path.join(xdg, APP_NAME);
+  return path.join(os.homedir(), '.cache', APP_NAME);
+}
+
+export function normalizeInstanceURL(url) {
+  if (!url) return '';
+  url = url.trim();
+  url = url.replace(/\/$/, '');
+  if (!/^https?:\/\//i.test(url)) {
+    url = 'https://' + url;
+  }
+  return url;
+}
+
+function loadFromFile(cfg, filePath, source) {
+  try {
+    const data = fs.readFileSync(filePath, 'utf-8');
+    const fileCfg = JSON.parse(data);
+    if (fileCfg.instance_url) {
+      cfg.instanceURL = fileCfg.instance_url;
+      cfg.sources.instance_url = source;
+    }
+    if (fileCfg.format) {
+      cfg.format = fileCfg.format;
+      cfg.sources.format = source;
+    }
+    if (fileCfg.default_profile) {
+      cfg.defaultProfile = fileCfg.default_profile;
+      cfg.activeProfile = fileCfg.default_profile;
+      cfg.sources.default_profile = source;
+    }
+    if (fileCfg.profiles && typeof fileCfg.profiles === 'object') {
+      cfg.profiles = { ...cfg.profiles, ...fileCfg.profiles };
+      cfg.sources.profiles = source;
+    }
+  } catch {
+    // File doesn't exist or is malformed — skip
+  }
+}
+
+function loadFromEnv(cfg) {
+  if (process.env.SERVICENOW_INSTANCE_URL) {
+    cfg.instanceURL = process.env.SERVICENOW_INSTANCE_URL;
+    cfg.sources.instance_url = 'env';
+  }
+  if (process.env.SERVICENOW_FORMAT) {
+    cfg.format = process.env.SERVICENOW_FORMAT;
+    cfg.sources.format = 'env';
+  }
+}
+
+export function createConfig() {
+  return {
+    instanceURL: '',
+    profiles: {},
+    defaultProfile: '',
+    activeProfile: '',
+    format: 'auto',
+    sources: {},
+  };
+}
+
+export function loadConfig(overrides = {}) {
+  const cfg = createConfig();
+
+  loadFromFile(cfg, globalConfigPath(), 'global');
+  loadFromFile(cfg, localConfigPath(), 'local');
+  loadFromEnv(cfg);
+
+  if (overrides.instance) {
+    cfg.instanceURL = overrides.instance;
+    cfg.sources.instance_url = 'flag';
+  }
+  if (overrides.format) {
+    cfg.format = overrides.format;
+    cfg.sources.format = 'flag';
+  }
+  if (overrides.profile) {
+    cfg.activeProfile = overrides.profile;
+    if (cfg.profiles[overrides.profile] && cfg.profiles[overrides.profile].instance_url) {
+      cfg.instanceURL = cfg.profiles[overrides.profile].instance_url;
+      cfg.sources.instance_url = 'profile';
+    }
+  }
+
+  return cfg;
+}
+
+export function saveConfig(cfg) {
+  const dir = globalConfigDir();
+  fs.mkdirSync(dir, { recursive: true, mode: 0o750 });
+  const payload = {
+    instance_url: cfg.instanceURL || undefined,
+    profiles: Object.keys(cfg.profiles).length > 0 ? cfg.profiles : undefined,
+    default_profile: cfg.defaultProfile || undefined,
+    format: cfg.format || undefined,
+  };
+  fs.writeFileSync(globalConfigPath(), JSON.stringify(payload, null, 2), { mode: 0o600 });
+}
+
+export function saveLocalConfig(cfg) {
+  const dir = path.dirname(localConfigPath());
+  fs.mkdirSync(dir, { recursive: true, mode: 0o750 });
+  const payload = {
+    instance_url: cfg.instanceURL || undefined,
+    profiles: Object.keys(cfg.profiles).length > 0 ? cfg.profiles : undefined,
+    default_profile: cfg.defaultProfile || undefined,
+    format: cfg.format || undefined,
+  };
+  fs.writeFileSync(localConfigPath(), JSON.stringify(payload, null, 2), { mode: 0o600 });
+}
+
+export function getEffectiveInstance(cfg) {
+  const name = cfg.activeProfile || cfg.defaultProfile;
+  if (name && cfg.profiles[name] && cfg.profiles[name].instance_url) {
+    return cfg.profiles[name].instance_url;
+  }
+  return cfg.instanceURL || '';
+}
+
+export function getActiveProfile(cfg) {
+  const name = cfg.activeProfile || cfg.defaultProfile;
+  if (!name) return null;
+  return cfg.profiles[name] || null;
+}
+
+export function setProfile(cfg, name, profile) {
+  cfg.profiles[name] = profile;
+  return saveConfig(cfg);
+}