ticketlens 0.10.18 → 0.11.0

package/README.md

@@ -79,7 +79,7 @@ Tip: `tl` works everywhere `ticketlens` does — running `tl`/`ticketlens config
 | `ticketlens profiles` | List all configured profiles (alias: `ticketlens ls`) |
 | `ticketlens delete <NAME>` | Remove a profile and its credentials (prompts `y/N` in TTY; use `--yes` in scripts/CI) |
 
-`init` collects: profile name, tracker type (Jira / GitHub Issues / Linear), URL or workspace, credentials (masked), and optional ticket prefixes, project paths, and triage statuses. On connection failure, a retry menu lets you fix credentials, URL, or skip — all inputs pre-populated. `config` is tracker-aware and always re-validates the connection after edits.
+`init` collects: profile name, tracker type (Jira / GitHub Issues / Linear), URL or workspace, credentials (masked), and optional ticket prefixes, project paths, and triage statuses. On connection failure, a retry menu lets you fix credentials, URL, or skip — all inputs pre-populated. If your Jira instance sits behind a VPN and resolves to a private/internal address, you'll be asked to confirm you trust that connection before it's allowed through — a one-time confirmation, remembered per profile and scoped to that exact host (changing the URL asks again). `config` is tracker-aware and always re-validates the connection after edits.
 
 `config` uses merge semantics: new ticket prefixes and triage statuses are added to existing lists, never replaced. Partial matching resolves `QA` to `QA Testing` if that's the status in your Jira.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.10.18",
+  "version": "0.11.0",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/SKILL.md

@@ -1,4 +1,4 @@
-<!-- jtb-skill-version: 0.10.18 -->
+<!-- jtb-skill-version: 0.11.0 -->
 ---
 name: jtb
 description: Fetch a Jira ticket's full context (description, comments, linked issues, code references) and assemble a structured TicketBrief for implementation planning. Use when user types /jtb, mentions a Jira ticket key, or wants to plan work from a Jira ticket.

package/skills/jtb/scripts/fetch-ticket.mjs

@@ -1134,7 +1134,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
       const authHeader = buildAuthHeader(jiraEnv);
       const apiVersion = conn.auth === 'cloud' ? 3 : 2;
       const jiraOrigin = new URL(jiraEnv.JIRA_BASE_URL).origin;
-      const links = await fetchRemoteLinks(ticketKey, { env: jiraEnv, fetcher, apiVersion });
+      const links = await fetchRemoteLinks(ticketKey, { env: jiraEnv, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp });
       const MAX_CONFLUENCE_PAGES = 10;
       const safeLinks = links
         .filter(l => { try { return new URL(l.url).origin === jiraOrigin; } catch { return false; } })
@@ -1189,6 +1189,7 @@ export async function run(args, envOrOpts = process.env, fetcher = globalThis.fe
         fetcher,
         noCache: args.includes('--no-cache'),
         onProgress: (msg) => process.stderr.write(msg + '\n'),
+        allowPrivateIp: conn.allowPrivateIp,
       });
       const downloaded = ticket.localAttachments.filter(r => !r.skipped).length;
       const cached = ticket.localAttachments.filter(r => r.skipReason === 'cached').length;

package/skills/jtb/scripts/lib/adapters/jira-adapter.mjs

@@ -11,9 +11,9 @@ export function createJiraAdapter(conn, { fetcher = globalThis.fetch } = {}) {
 
   return {
     type: 'jira',
-    fetchTicket: (key, opts = {}) => fetchTicket(key, { env, fetcher, apiVersion, ...opts }),
-    fetchCurrentUser: (opts = {}) => fetchCurrentUser({ env, fetcher, apiVersion, ...opts }),
-    searchTickets: (query, opts = {}) => searchTickets(query, { env, fetcher, apiVersion, ...opts }),
-    fetchStatuses: (opts = {}) => fetchStatuses({ env, fetcher, apiVersion, ...opts }),
+    fetchTicket: (key, opts = {}) => fetchTicket(key, { env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
+    fetchCurrentUser: (opts = {}) => fetchCurrentUser({ env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
+    searchTickets: (query, opts = {}) => searchTickets(query, { env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
+    fetchStatuses: (opts = {}) => fetchStatuses({ env, fetcher, apiVersion, allowPrivateIp: conn.allowPrivateIp, ...opts }),
   };
 }

package/skills/jtb/scripts/lib/attachment-downloader.mjs

@@ -20,10 +20,15 @@ const MAX_REDIRECT_HOPS = 2;
  * code-review remediation). Auth headers are only ever sent on the initial
  * request — every hop after that is auth-less, matching Jira Cloud's
  * presigned-URL CDN redirect model.
+ *
+ * `allowPrivateIp` only ever applies to the initial hop (the user's own
+ * trusted Jira origin). A redirect target is server-controlled — a
+ * categorically different trust domain — so it is never passed through,
+ * regardless of the caller's trust level.
  */
-async function followValidatedRedirects(initialUrl, fetcher, lookup, headers) {
+async function followValidatedRedirects(initialUrl, fetcher, lookup, headers, allowPrivateIp = false) {
   let url = initialUrl;
-  await validateResolvedHost(new URL(url).hostname, lookup);
+  await validateResolvedHost(new URL(url).hostname, lookup, allowPrivateIp);
   let response = await fetcher(url, { headers, redirect: 'manual' });
   let hops = 0;
   while (response.status >= 300 && response.status < 400) {
@@ -53,6 +58,7 @@ async function followValidatedRedirects(initialUrl, fetcher, lookup, headers) {
  * @param {string} opts.configDir Base config dir (default: ~/.ticketlens)
  * @param {boolean} opts.noCache  Force re-download even if cached (default: false)
  * @param {Function} opts.onProgress  Optional callback(msg: string) for progress lines
+ * @param {boolean} opts.allowPrivateIp  Skip the private-IP DNS check on the initial hop only (default: false)
  *
  * @returns {Promise<Array<{filename, mimeType, size, localPath, skipped, skipReason, error}>>}
  */
@@ -64,6 +70,7 @@ export async function downloadAttachments(ticket, opts = {}) {
     configDir = DEFAULT_CONFIG_DIR,
     noCache = false,
     onProgress = null,
+    allowPrivateIp = false,
   } = opts;
 
   const attachments = (ticket.attachments ?? []).filter(a => a.content);
@@ -118,7 +125,7 @@ export async function downloadAttachments(ticket, opts = {}) {
       onProgress?.(`  download  ${a.filename}`);
       try {
         const headers = buildAuthHeader(env);
-        const response = await followValidatedRedirects(a.content, fetcher, lookup, headers);
+        const response = await followValidatedRedirects(a.content, fetcher, lookup, headers, allowPrivateIp);
         if (!response.ok) throw new Error(`HTTP ${response.status} (${response.statusText})`);
         const buffer = await response.arrayBuffer();
         fs.writeFileSync(localPath, Buffer.from(buffer));

package/skills/jtb/scripts/lib/config-wizard.mjs

@@ -16,7 +16,7 @@ import { loadProfiles, loadCredentials, saveProfile } from './profile-resolver.m
 import { promptSelect } from './select-prompt.mjs';
 import { parseAge } from './cache-manager.mjs';
 import { DEFAULT_BRIEF_TTL } from './brief-cache.mjs';
-import { DEFAULT_CONFIG_DIR } from './config.mjs';
+import { DEFAULT_CONFIG_DIR, hostnameOf } from './config.mjs';
 import { visLen, SERVER_AUTH_TYPES, promptText, promptSecret, promptYN } from './prompt-helpers.mjs';
 import { isLicensed } from './license.mjs';
 import { siteBase } from './api-utils.mjs';
@@ -103,6 +103,10 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
   let email = profile.email || '';
   const existingToken = profileCreds.pat || profileCreds.apiToken || '';
   let token = existingToken;
+  // Trust is bound to the exact hostname it was granted for — never a flat
+  // per-profile boolean. Editing the URL to a different host must re-trigger
+  // the private-IP block and a fresh "Trust this connection?" prompt.
+  let trustedHostname = (profile.allowPrivateIp && hostnameOf(profile.baseUrl)) || null;
 
   // ── URL ───────────────────────────────────────────────────────────────────
   const urlTyped = await promptText(
@@ -158,6 +162,24 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
   let connected = false;
   let startFrom = 'test';
 
+  function isTrustedForCurrentUrl() {
+    return trustedHostname !== null && hostnameOf(url) === trustedHostname;
+  }
+
+  async function attemptConnection() {
+    if (isJira) {
+      const testEnv = {
+        JIRA_BASE_URL: url,
+        JIRA_EMAIL: email,
+        JIRA_API_TOKEN: auth !== 'pat' ? token : '',
+        JIRA_PAT: auth === 'pat' ? token : '',
+      };
+      await fetchCurrentUser({ env: testEnv, apiVersion: auth === 'cloud' ? 3 : 2, allowPrivateIp: isTrustedForCurrentUrl() });
+    } else {
+      await resolveAdapter({ baseUrl: url, auth: trackerType, apiToken: token }).fetchCurrentUser();
+    }
+  }
+
   setupLoop: while (true) {
     // Re-prompt URL + auth (on retry with 'url' option)
     if (startFrom === 'url') {
@@ -216,17 +238,7 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
       session.spin('Testing connection...');
 
       try {
-        if (isJira) {
-          const testEnv = {
-            JIRA_BASE_URL: url,
-            JIRA_EMAIL: email,
-            JIRA_API_TOKEN: auth !== 'pat' ? token : '',
-            JIRA_PAT: auth === 'pat' ? token : '',
-          };
-          await fetchCurrentUser({ env: testEnv, apiVersion: auth === 'cloud' ? 3 : 2 });
-        } else {
-          await resolveAdapter({ baseUrl: url, auth: trackerType, apiToken: token }).fetchCurrentUser();
-        }
+        await attemptConnection();
         session.connected();
         connected = true;
         break setupLoop;
@@ -234,6 +246,15 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
         session.failed();
         const classified = classifyError(err, { baseUrl: url, profileName: target });
         session.footer(classified.message, 'error', classified.hint);
+
+        if (classified.privateIpBlocked) {
+          const trust = await promptYN('Trust this connection?', { stream });
+          if (trust) {
+            trustedHostname = hostnameOf(url);
+            startFrom = 'test';
+            continue setupLoop;
+          }
+        }
       }
 
       stream.write(`\n  ${s.dim('What would you like to do?')}\n\n`);
@@ -326,7 +347,7 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
             JIRA_API_TOKEN: auth !== 'pat' ? token : '',
             JIRA_PAT: auth === 'pat' ? token : '',
           };
-          available = await fetchStatuses({ env: validateEnv, apiVersion: auth === 'cloud' ? 3 : 2 });
+          available = await fetchStatuses({ env: validateEnv, apiVersion: auth === 'cloud' ? 3 : 2, allowPrivateIp: isTrustedForCurrentUrl() });
         } else {
           available = await resolveAdapter({ baseUrl: url, auth: trackerType, apiToken: token }).fetchStatuses();
         }
@@ -397,6 +418,8 @@ export async function run({ configDir = DEFAULT_CONFIG_DIR, profileName } = {})
   else delete updated.projectPaths;
   if (cacheTtl && cacheTtl !== DEFAULT_BRIEF_TTL) updated.cacheTtl = cacheTtl;
   else delete updated.cacheTtl;
+  if (isTrustedForCurrentUrl()) updated.allowPrivateIp = true;
+  else delete updated.allowPrivateIp;
 
   const credData = (token !== existingToken)
     ? (auth === 'pat' ? { pat: token } : { apiToken: token })

package/skills/jtb/scripts/lib/config.mjs

@@ -68,6 +68,12 @@ export function stripCr(str) {
   return str.replace(/\r/g, '');
 }
 
+/** Parse a URL's hostname, or null if unparseable. Used to scope trust
+ * grants (e.g. allowPrivateIp) to the exact host they were confirmed for. */
+export function hostnameOf(url) {
+  try { return new URL(url).hostname; } catch { return null; }
+}
+
 /**
  * Build the env-like object expected by jira-client functions.
  * @param {{ baseUrl: string, pat?: string, email?: string, apiToken?: string }} conn

package/skills/jtb/scripts/lib/connection-tester.mjs

@@ -29,6 +29,7 @@ export async function testConnections({
       email: profile.email,
       apiToken: profileCreds.apiToken,
       pat: profileCreds.pat,
+      allowPrivateIp: profile.allowPrivateIp,
     };
 
     const session = createSession(

package/skills/jtb/scripts/lib/error-classifier.mjs

@@ -18,6 +18,15 @@ export function classifyError(err, { baseUrl, profileName } = {}) {
   const profile = profileName || 'your profile';
   const code = getNetworkCode(err);
 
+  if (err.code === 'PRIVATE_IP_BLOCKED') {
+    const address = err.blockedAddress ? ` (${err.blockedAddress})` : '';
+    return {
+      message: `${err.blockedHostname} resolves to a private address${address}`,
+      hint: "This is expected if you're on a VPN connecting to an on-prem Jira instance. It could also mean something is wrong.",
+      privateIpBlocked: true,
+    };
+  }
+
   // Network-level errors (fetch threw before getting an HTTP response)
   if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') {
     return {

package/skills/jtb/scripts/lib/init-wizard.mjs

@@ -16,7 +16,7 @@ import { promptSelect } from './select-prompt.mjs';
 import { runSwitch } from './profile-switcher.mjs';
 import { renderWordmark } from './wordmark.mjs';
 import { printQuickStart } from './quick-start-panel.mjs';
-import { DEFAULT_CONFIG_DIR } from './config.mjs';
+import { DEFAULT_CONFIG_DIR, hostnameOf } from './config.mjs';
 import { SERVER_AUTH_TYPES, promptText, promptSecret, promptYN } from './prompt-helpers.mjs';
 
 const RETRY_OPTIONS = [
@@ -328,6 +328,12 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
     let baseUrl = '', authType = '', email = '', token = '';
     let env = {}, apiVersion = 2;
     let startFrom = 'url';
+    // Trust is bound to the exact hostname it was granted for — never a flat
+    // per-run boolean. Choosing "Edit from URL" after granting trust for one
+    // host must re-trigger the private-IP block and a fresh confirmation
+    // for the new host, not silently inherit trust.
+    let trustedHostname = null;
+    const isTrustedForCurrentUrl = () => trustedHostname !== null && hostnameOf(baseUrl) === trustedHostname;
 
     setupLoop: while (true) {
       // ── URL + auth type ────────────────────────────────────────────────────
@@ -432,7 +438,7 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
       session.spin('Testing connection...');
 
       try {
-        await fetchCurrentUser({ env, apiVersion });
+        await fetchCurrentUser({ env, apiVersion, allowPrivateIp: isTrustedForCurrentUrl() });
         session.connected();
         connected = true;
         break setupLoop;
@@ -440,6 +446,15 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
         session.failed();
         const classified = classifyError(err, { baseUrl, profileName });
         session.footer(classified.message, 'error', classified.hint);
+
+        if (classified.privateIpBlocked) {
+          const trust = await promptYN('Trust this connection?', { stream });
+          if (trust) {
+            trustedHostname = hostnameOf(baseUrl);
+            startFrom = 'retry';
+            continue setupLoop;
+          }
+        }
       }
 
       // ── Retry options ──────────────────────────────────────────────────────
@@ -503,7 +518,7 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
 
       stream.write(`  ${s.dim('Validating statuses...')}\n`);
       try {
-        const available = await fetchStatuses({ env, apiVersion });
+        const available = await fetchStatuses({ env, apiVersion, allowPrivateIp: isTrustedForCurrentUrl() });
         const lowerMap = new Map(available.map(n => [n.toLowerCase(), n]));
         stream.write('\x1b[A\r\x1b[2K'); // clear "Validating..." line
         const corrected = [];
@@ -540,6 +555,7 @@ async function _run({ configDir, stream, s, showBanner, showQuickStart }) {
         ...(email ? { email } : {}),
         ...(ticketPrefixes.length > 0 ? { ticketPrefixes } : {}),
         ...(projectPaths.length > 0 ? { projectPaths } : {}),
+        ...(isTrustedForCurrentUrl() ? { allowPrivateIp: true } : {}),
         triageStatuses,
       };
       const credData = authType === 'pat' ? { pat: token } : { apiToken: token };

package/skills/jtb/scripts/lib/jira-client.mjs

@@ -125,7 +125,14 @@ function normalizeHostname(hostname) {
   return hostname.replace(/^\[|\]$/g, '').replace(/\.$/, '');
 }
 
-export function validateBaseUrl(url) {
+/**
+ * @param {string} url
+ * @param {boolean} [allowPrivateIp] - skip the private/internal blocklist check
+ *   for THIS hostname. Set only via explicit interactive user confirmation
+ *   during setup, persisted per-profile — never from synced/network data
+ *   (see team-jira-sync.mjs). HTTPS enforcement is never skippable.
+ */
+export function validateBaseUrl(url, allowPrivateIp = false) {
   let parsed;
   try { parsed = new URL(url); } catch {
     throw new Error(`JIRA_BASE_URL is not a valid URL: ${url}`);
@@ -133,9 +140,14 @@ export function validateBaseUrl(url) {
   if (parsed.protocol !== 'https:') {
     throw new Error(`JIRA_BASE_URL must use HTTPS (got ${parsed.protocol})`);
   }
+  if (allowPrivateIp) return;
   const hostname = normalizeHostname(parsed.hostname);
   if (BLOCKED_PATTERNS.some(re => re.test(hostname))) {
-    throw new Error(`JIRA_BASE_URL hostname is blocked (${hostname})`);
+    const err = new Error(`JIRA_BASE_URL hostname is blocked (${hostname})`);
+    err.code = 'PRIVATE_IP_BLOCKED';
+    err.blockedHostname = hostname;
+    err.blockedAddress = null;
+    throw err;
   }
 }
 
@@ -189,9 +201,17 @@ const dnsValidationCaches = new WeakMap();
  * `lookup` is null when the fetcher is mocked (tests) — no socket opens, so
  * there is nothing to protect. Production always uses globalThis.fetch, which
  * always gets the real resolver (see defaultLookupFor).
+ *
+ * `allowPrivateIp` skips the lookup entirely (not just the block) when a
+ * profile has an explicit, user-confirmed trust exception for this exact
+ * hostname — set only during interactive setup, never from synced/network
+ * data. Skipping the resolution outright (rather than resolving-then-
+ * ignoring) avoids the DNS round-trip and sidesteps any question of how the
+ * per-lookup-fn cache should key on a flag that no real caller varies
+ * concurrently for the same hostname.
  */
-export async function validateResolvedHost(hostname, lookup) {
-  if (!lookup) return;
+export async function validateResolvedHost(hostname, lookup, allowPrivateIp = false) {
+  if (!lookup || allowPrivateIp) return;
   let cache = dnsValidationCaches.get(lookup);
   if (!cache) {
     cache = new Map();
@@ -202,7 +222,11 @@ export async function validateResolvedHost(hostname, lookup) {
       const addresses = await lookup(hostname, { all: true });
       for (const { address } of addresses) {
         if (BLOCKED_PATTERNS.some(re => re.test(address))) {
-          throw new Error(`Hostname ${hostname} resolves to a blocked address (${address}) — refusing to connect`);
+          const err = new Error(`Hostname ${hostname} resolves to a blocked address (${address}) — refusing to connect`);
+          err.code = 'PRIVATE_IP_BLOCKED';
+          err.blockedHostname = hostname;
+          err.blockedAddress = address;
+          throw err;
         }
       }
     })();
@@ -223,8 +247,8 @@ export async function validateResolvedHost(hostname, lookup) {
  * Error message carries the redirect target's HOSTNAME only — Location values
  * can contain presigned tokens in path/query.
  */
-export async function guardedFetch(url, fetchOpts, { fetcher, lookup }) {
-  await validateResolvedHost(new URL(url).hostname, lookup);
+export async function guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp = false }) {
+  await validateResolvedHost(new URL(url).hostname, lookup, allowPrivateIp);
   const response = await fetcher(url, { ...fetchOpts, redirect: 'manual' });
   if (response.status >= 300 && response.status < 400) {
     let target = 'unknown host';
@@ -248,15 +272,15 @@ export function buildAuthHeader(env) {
 }
 
 export async function fetchCurrentUser(opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
 
   const url = `${baseUrl}/rest/api/${apiVersion}/myself`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     const err = new Error(`Jira API error ${response.status} fetching current user`);
@@ -274,15 +298,15 @@ export async function fetchCurrentUser(opts = {}) {
 }
 
 export async function fetchStatuses(opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
 
   const url = `${baseUrl}/rest/api/${apiVersion}/status`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     const err = new Error(`Jira API error ${response.status} fetching statuses`);
@@ -295,8 +319,8 @@ export async function fetchStatuses(opts = {}) {
 }
 
 export async function searchTickets(jql, opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), maxResults = 50, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), maxResults = 50, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
 
@@ -307,7 +331,7 @@ export async function searchTickets(jql, opts = {}) {
   const url = `${baseUrl}${endpoint}?${params}`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     let detail = '';
@@ -323,15 +347,15 @@ export async function searchTickets(jql, opts = {}) {
 }
 
 export async function fetchRemoteLinks(ticketKey, opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}/remotelink`;
 
   const fetchOpts = { headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' } };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
 
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
   if (!response.ok) return [];
 
   const raw = await response.json();
@@ -341,8 +365,8 @@ export async function fetchRemoteLinks(ticketKey, opts = {}) {
 }
 
 export async function fetchTicket(ticketKey, opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), depth = 1, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false, _visited = new Set(), _currentDepth = 0 } = opts;
-  validateBaseUrl(env.JIRA_BASE_URL);
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), depth = 1, apiVersion = 2, timeoutMs = 10_000, expandChangelog = false, allowPrivateIp = false, _visited = new Set(), _currentDepth = 0 } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
 
@@ -350,7 +374,7 @@ export async function fetchTicket(ticketKey, opts = {}) {
   const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}${expand}`;
   const fetchOpts = { headers };
   if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
-  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup });
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
 
   if (!response.ok) {
     const err = new Error(`Jira API error ${response.status} fetching ${ticketKey}`);

package/skills/jtb/scripts/lib/profile-resolver.mjs

@@ -233,6 +233,7 @@ export function resolveConnection(ticketKey, opts = {}) {
       ticketPrefixes: profile.ticketPrefixes || null,
       attentionRules: profile.attentionRules ?? null,
       staleRule: profile.staleRule ?? null,
+      allowPrivateIp: profile.allowPrivateIp || false,
       source: 'profile',
       profileName: profile.name,
     };

package/skills/jtb/scripts/lib/profile-switcher.mjs

@@ -118,6 +118,7 @@ export async function runSwitch({ configDir = DEFAULT_CONFIG_DIR, stream = proce
     JIRA_PAT: profileCreds.pat || '',
   };
   const apiVersion = profile.auth === 'cloud' ? 3 : 2;
+  const allowPrivateIp = profile.allowPrivateIp;
 
   let frame = 0;
   const spinLine = () => `  ${s.cyan(SPINNER_FRAMES[frame])} Connecting to ${s.bold(chosen.name)}...`;
@@ -129,7 +130,7 @@ export async function runSwitch({ configDir = DEFAULT_CONFIG_DIR, stream = proce
   }, 80);
 
   try {
-    await fetchCurrentUser({ env, apiVersion });
+    await fetchCurrentUser({ env, apiVersion, allowPrivateIp });
     clearInterval(timer);
     stream.write('\r\x1b[2K\x1b[A\r\x1b[2K');
     await saveDefault(chosen.name, configDir);

package/skills/jtb/scripts/lib/team-jira-sync.mjs

@@ -9,7 +9,7 @@ import { join } from 'node:path';
 import { readCliToken } from './cli-auth.mjs';
 import { saveProfile, loadProfiles } from './profile-resolver.mjs';
 import { apiBase } from './api-utils.mjs';
-import { DEFAULT_CONFIG_DIR } from './config.mjs';
+import { DEFAULT_CONFIG_DIR, hostnameOf } from './config.mjs';
 
 const META_FILE = 'team-jira-meta.json';
 
@@ -78,11 +78,23 @@ function teamConfigToCliProfile(apiData) {
 
 /**
  * Writes team config to the named profile without touching credentials.
+ * Carries forward `allowPrivateIp` from the existing LOCAL profile only —
+ * never from server data (see teamConfigToCliProfile) — and only when the
+ * synced baseUrl resolves to the SAME hostname the trust was granted for.
+ * A sync that changes the host (legitimate re-point, or a compromised/
+ * malicious sync response) must never inherit trust for a different,
+ * unconfirmed host — the member has to re-confirm via the wizard.
  * Returns { error, message } on failure — never throws.
  */
 async function applyTeamJiraConfig(groupName, profileData, configDir) {
   try {
-    await saveProfile(groupName, profileData, null, configDir);
+    const existing = loadProfiles(configDir)?.profiles?.[groupName];
+    const sameHost = existing?.baseUrl && profileData.baseUrl &&
+      hostnameOf(existing.baseUrl) === hostnameOf(profileData.baseUrl);
+    const merged = (existing?.allowPrivateIp && sameHost)
+      ? { ...profileData, allowPrivateIp: true }
+      : profileData;
+    await saveProfile(groupName, merged, null, configDir);
     return { ok: true };
   } catch (e) {
     return { error: 'save-failed', message: e.message };