jira-ai 0.6.3 → 0.6.4

package/dist/commands/confluence.js

@@ -1,15 +1,32 @@
 import chalk from 'chalk';
-import { getPage, getPageComments } from '../lib/confluence-client.js';
+import { getPage, getPageComments, parseConfluenceUrl } from '../lib/confluence-client.js';
 import { formatConfluencePage } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
 import { CommandError } from '../lib/errors.js';
+import { isConfluenceSpaceAllowed } from '../lib/settings.js';
 export async function confluenceGetPageCommand(url) {
+    // Check permission before fetching if space key can be extracted from URL
+    try {
+        const { spaceKey } = parseConfluenceUrl(url);
+        if (spaceKey && !isConfluenceSpaceAllowed(spaceKey)) {
+            throw new CommandError(`Access to Confluence space '${spaceKey}' is restricted by your settings.`);
+        }
+    }
+    catch (e) {
+        if (e instanceof CommandError)
+            throw e;
+        // If URL parsing fails, let the fetch attempt handle it or catch it later
+    }
     ui.startSpinner(`Fetching Confluence page details for: ${url}`);
     try {
         const [page, comments] = await Promise.all([
             getPage(url),
             getPageComments(url)
         ]);
+        // Double check with the actual space name/key from the fetched page
+        if (!isConfluenceSpaceAllowed(page.space)) {
+            throw new CommandError(`Access to Confluence space '${page.space}' is restricted by your settings.`);
+        }
         ui.succeedSpinner(chalk.green('Confluence page details retrieved'));
         console.log(formatConfluencePage(page, comments));
     }

package/dist/commands/settings.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import fs from 'fs';
 import yaml from 'js-yaml';
-import { loadSettings, saveSettings, DEFAULT_SETTINGS } from '../lib/settings.js';
+import { loadSettings, saveSettings, DEFAULT_SETTINGS, migrateSettings } from '../lib/settings.js';
 import { formatSettings } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
 import { SettingsSchema } from '../lib/validation.js';
@@ -57,23 +57,33 @@ async function validateSettingsFile(filePath) {
             .join('\n');
         throw new CommandError(`Invalid settings structure:\n${messages}`);
     }
-    const settings = result.data;
+    const settings = migrateSettings(result.data);
     // Deep Validation
     ui.updateSpinner('Performing deep validation against Jira...');
     try {
         validateEnvVars();
         const projects = await getProjects();
         const projectKeys = new Set(projects.map(p => p.key));
-        for (const p of settings.projects) {
-            const key = typeof p === 'string' ? p : p.key;
-            if (key === 'all')
-                continue;
-            if (!projectKeys.has(key)) {
-                ui.failSpinner(`Deep validation failed: Project "${key}" not found in Jira.`);
-                throw new CommandError(`Project "${key}" not found in Jira.`);
+        const validateOrg = (orgSettings, label) => {
+            const projectsToValidate = orgSettings['allowed-jira-projects'] || [];
+            for (const p of projectsToValidate) {
+                const key = typeof p === 'string' ? p : p.key;
+                if (key === 'all')
+                    continue;
+                if (!projectKeys.has(key)) {
+                    const msg = `Project "${key}" (in ${label}) not found in Jira.`;
+                    ui.failSpinner(`Deep validation failed: ${msg}`);
+                    throw new CommandError(msg);
+                }
+            }
+        };
+        if (settings.defaults) {
+            validateOrg(settings.defaults, 'defaults');
+        }
+        if (settings.organizations) {
+            for (const [alias, orgSettings] of Object.entries(settings.organizations)) {
+                validateOrg(orgSettings, `organizations.${alias}`);
             }
-            // If project has specific commands, we could validate them too, 
-            // but they are just strings matched against command names.
         }
         ui.succeedSpinner(chalk.green('Settings are valid!'));
         return settings;

package/dist/lib/auth-storage.js

@@ -137,10 +137,24 @@ export function getOrganizations() {
     const config = loadConfig();
     return config.organizations;
 }
+let organizationOverride = undefined;
 /**
- * Get the currently active organization alias
+
+ * Set a global organization override for the current execution
+
+ */
+export function setOrganizationOverride(alias) {
+    organizationOverride = alias;
+}
+/**
+
+ * Get the currently active organization alias, respecting override
+
  */
 export function getCurrentOrganizationAlias() {
+    if (organizationOverride) {
+        return organizationOverride;
+    }
     const config = loadConfig();
     return config.current;
 }

package/dist/lib/confluence-client.js

@@ -1,13 +1,12 @@
 import { ConfluenceClient } from 'confluence.js';
-import { loadCredentials } from './auth-storage.js';
+import { loadCredentials, getCurrentOrganizationAlias, setOrganizationOverride as setAuthOrgOverride } from './auth-storage.js';
 import { convertADFToMarkdown } from './utils.js';
 let confluenceClient = null;
-let organizationOverride = undefined;
 /**
  * Set a global organization override for the current execution
  */
 export function setOrganizationOverride(alias) {
-    organizationOverride = alias;
+    setAuthOrgOverride(alias);
     confluenceClient = null; // Force client recreation
 }
 /**
@@ -30,7 +29,8 @@ export function getConfluenceClient() {
             });
         }
         else {
-            const storedCreds = loadCredentials(organizationOverride);
+            const alias = getCurrentOrganizationAlias();
+            const storedCreds = loadCredentials(alias);
             if (storedCreds) {
                 confluenceClient = new ConfluenceClient({
                     host: storedCreds.host.replace(/\/$/, ''),
@@ -43,8 +43,8 @@ export function getConfluenceClient() {
                 });
             }
             else {
-                const errorMsg = organizationOverride
-                    ? `Credentials for organization "${organizationOverride}" not found.`
+                const errorMsg = alias
+                    ? `Credentials for organization "${alias}" not found.`
                     : 'Credentials not found. Please set environment variables or run "jira-ai auth"';
                 throw new Error(errorMsg);
             }
@@ -53,20 +53,22 @@ export function getConfluenceClient() {
     return confluenceClient;
 }
 /**
- * Parse Confluence URL to extract page ID
+ * Parse Confluence URL to extract page ID and space key
  */
 export function parseConfluenceUrl(url) {
     try {
         const parsedUrl = new URL(url);
         // Pattern: /wiki/spaces/SPACE/pages/PAGE_ID/TITLE
+        const spaceMatch = parsedUrl.pathname.match(/\/spaces\/([^/]+)/);
+        const spaceKey = spaceMatch ? spaceMatch[1] : undefined;
         const pagesMatch = parsedUrl.pathname.match(/\/pages\/(\d+)/);
         if (pagesMatch && pagesMatch[1]) {
-            return pagesMatch[1];
+            return { pageId: pagesMatch[1], spaceKey };
         }
         // Pattern: /wiki/pages/viewpage.action?pageId=PAGE_ID
         const pageIdParam = parsedUrl.searchParams.get('pageId');
         if (pageIdParam) {
-            return pageIdParam;
+            return { pageId: pageIdParam, spaceKey };
         }
         throw new Error('Could not extract Page ID from URL');
     }
@@ -82,7 +84,7 @@ export function parseConfluenceUrl(url) {
  */
 export async function getPage(url) {
     const client = getConfluenceClient();
-    const pageId = parseConfluenceUrl(url);
+    const { pageId } = parseConfluenceUrl(url);
     const page = await client.content.getContentById({
         id: pageId,
         expand: ['body.atlas_doc_format', 'version', 'space', 'history.lastUpdated'],
@@ -108,7 +110,7 @@ export async function getPage(url) {
  */
 export async function getPageComments(url) {
     const client = getConfluenceClient();
-    const pageId = parseConfluenceUrl(url);
+    const { pageId } = parseConfluenceUrl(url);
     const response = await client.contentChildrenAndDescendants.getContentChildrenByType({
         id: pageId,
         type: 'comment',

package/dist/lib/formatters.js

@@ -461,17 +461,18 @@ export function formatWorklogs(worklogs, groupByIssue = false) {
     return output;
 }
 /**
- * Format settings
+ * Format organization settings
  */
-export function formatSettings(settings) {
-    let output = '\n' + chalk.bold.cyan('Active Configuration') + '\n\n';
-    // Global Commands
-    output += chalk.bold('Global Commands:') + '\n';
-    output += `  ${settings.commands.join(', ')}\n\n`;
-    // Projects
-    output += chalk.bold(`Projects (${settings.projects.length}):`) + '\n';
+function formatOrgSettings(settings, title) {
+    let output = chalk.bold(`${title}:`) + '\n';
+    const commands = settings['allowed-commands'] || [];
+    output += `  ${chalk.bold('Allowed Commands:')} ${commands.join(', ')}\n`;
+    const spaces = settings['allowed-confluence-spaces'] || [];
+    output += `  ${chalk.bold('Allowed Confluence Spaces:')} ${spaces.join(', ')}\n\n`;
+    const projects = settings['allowed-jira-projects'] || [];
+    output += `  ${chalk.bold(`Allowed Jira Projects (${projects.length}):`)}\n`;
     const table = createTable(['Project', 'Commands', 'Filters'], [15, 30, 50]);
-    settings.projects.forEach((p) => {
+    projects.forEach((p) => {
         let key;
         let commands = 'global';
         let filters = 'none';
@@ -511,7 +512,23 @@ export function formatSettings(settings) {
             filters
         ]);
     });
-    output += table.toString() + '\n';
+    output += table.toString().split('\n').map(line => '  ' + line).join('\n') + '\n\n';
+    return output;
+}
+/**
+ * Format settings
+ */
+export function formatSettings(settings) {
+    let output = '\n' + chalk.bold.cyan('Active Configuration') + '\n\n';
+    if (settings.defaults) {
+        output += formatOrgSettings(settings.defaults, 'Default Settings');
+    }
+    if (settings.organizations && Object.keys(settings.organizations).length > 0) {
+        output += chalk.bold.blue('Organization-Specific Settings:') + '\n\n';
+        for (const [alias, orgSettings] of Object.entries(settings.organizations)) {
+            output += formatOrgSettings(orgSettings, `Organization: ${alias}`);
+        }
+    }
     return output;
 }
 /**

package/dist/lib/jira-client.js

@@ -1,15 +1,14 @@
 import { Version3Client } from 'jira.js';
 import { calculateStatusStatistics, convertADFToMarkdown } from './utils.js';
-import { loadCredentials } from './auth-storage.js';
-import { applyGlobalFilters, isProjectAllowed, isCommandAllowed, validateIssueAgainstFilters, loadSettings } from './settings.js';
+import { loadCredentials, getCurrentOrganizationAlias, setOrganizationOverride as setAuthOrgOverride } from './auth-storage.js';
+import { applyGlobalFilters, isProjectAllowed, isCommandAllowed, validateIssueAgainstFilters, getAllowedProjects } from './settings.js';
 import { CommandError } from './errors.js';
 let jiraClient = null;
-let organizationOverride = undefined;
 /**
  * Set a global organization override for the current execution
  */
 export function setOrganizationOverride(alias) {
-    organizationOverride = alias;
+    setAuthOrgOverride(alias);
     jiraClient = null; // Force client recreation
 }
 /**
@@ -32,7 +31,8 @@ export function getJiraClient() {
             });
         }
         else {
-            const storedCreds = loadCredentials(organizationOverride);
+            const alias = getCurrentOrganizationAlias();
+            const storedCreds = loadCredentials(alias);
             if (storedCreds) {
                 jiraClient = new Version3Client({
                     host: storedCreds.host,
@@ -45,8 +45,8 @@ export function getJiraClient() {
                 });
             }
             else {
-                const errorMsg = organizationOverride
-                    ? `Jira credentials for organization "${organizationOverride}" not found.`
+                const errorMsg = alias
+                    ? `Jira credentials for organization "${alias}" not found.`
                     : 'Jira credentials not found. Please set environment variables or run "jira-ai auth"';
                 throw new Error(errorMsg);
             }
@@ -374,10 +374,10 @@ export async function validateIssuePermissions(issueKey, commandName, options =
         });
     }
     // Check JQL filters
-    const settings = loadSettings();
-    let project = settings.projects.find(p => typeof p !== 'string' && p.key === projectKey);
+    const allowedProjects = getAllowedProjects();
+    let project = allowedProjects.find(p => typeof p !== 'string' && p.key === projectKey);
     if (!project) {
-        project = settings.projects.find(p => typeof p === 'string' && (p === 'all' || p === projectKey));
+        project = allowedProjects.find(p => typeof p === 'string' && (p === 'all' || p === projectKey));
     }
     if (project && typeof project !== 'string' && project.filters?.jql) {
         const client = getJiraClient();

package/dist/lib/settings.js

@@ -5,9 +5,10 @@ import yaml from 'js-yaml';
 import chalk from 'chalk';
 import { CliError } from '../types/errors.js';
 import { SettingsSchema } from './validation.js';
-export const DEFAULT_SETTINGS = {
-    projects: ['all'],
-    commands: [
+import { getCurrentOrganizationAlias } from './auth-storage.js';
+export const DEFAULT_ORG_SETTINGS = {
+    'allowed-jira-projects': ['all'],
+    'allowed-commands': [
         'me',
         'projects',
         'task-with-details',
@@ -24,8 +25,12 @@ export const DEFAULT_SETTINGS = {
         'organization',
         'transition',
         'update-description',
-        'confl'
-    ]
+        'confluence'
+    ],
+    'allowed-confluence-spaces': ['all']
+};
+export const DEFAULT_SETTINGS = {
+    defaults: DEFAULT_ORG_SETTINGS
 };
 const CONFIG_DIR = path.join(os.homedir(), '.jira-ai');
 const SETTINGS_FILE = path.join(CONFIG_DIR, 'settings.yaml');
@@ -33,6 +38,25 @@ let cachedSettings = null;
 export function getSettingsPath() {
     return SETTINGS_FILE;
 }
+export function migrateSettings(settings) {
+    // Migration logic: if old structure exists, move it to defaults
+    if (settings.projects || settings.commands) {
+        const migratedDefaults = {
+            'allowed-jira-projects': settings.projects || DEFAULT_ORG_SETTINGS['allowed-jira-projects'],
+            'allowed-commands': settings.commands || DEFAULT_ORG_SETTINGS['allowed-commands'],
+            'allowed-confluence-spaces': DEFAULT_ORG_SETTINGS['allowed-confluence-spaces']
+        };
+        const newSettings = {
+            ...settings,
+            defaults: migratedDefaults,
+        };
+        // Remove old fields
+        delete newSettings.projects;
+        delete newSettings.commands;
+        return newSettings;
+    }
+    return settings;
+}
 export function loadSettings() {
     if (cachedSettings) {
         return cachedSettings;
@@ -78,17 +102,13 @@ export function loadSettings() {
             result.error.issues.forEach(issue => {
                 console.warn(chalk.yellow(`  - ${issue.path.join('.')}: ${issue.message}`));
             });
-            // Fallback to raw settings or default if parsing fails completely
-            const settings = rawSettings;
-            cachedSettings = {
-                projects: settings?.projects || DEFAULT_SETTINGS.projects,
-                commands: settings?.commands || DEFAULT_SETTINGS.commands
-            };
+            // Fallback to defaults if parsing fails completely
+            return DEFAULT_SETTINGS;
         }
-        else {
-            cachedSettings = result.data;
-        }
-        return cachedSettings;
+        let settings = result.data;
+        settings = migrateSettings(settings);
+        cachedSettings = settings;
+        return settings;
     }
     catch (error) {
         throw new CliError(`Error loading ${SETTINGS_FILE}: ${error instanceof Error ? error.message : String(error)}`);
@@ -108,9 +128,19 @@ export function saveSettings(settings) {
         throw new CliError(`Error saving ${SETTINGS_FILE}: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-export function isProjectAllowed(projectKey) {
+function getEffectiveSettings(orgAlias) {
     const settings = loadSettings();
-    const isAllowed = settings.projects.some(p => {
+    const alias = orgAlias || getCurrentOrganizationAlias();
+    if (alias && settings.organizations && settings.organizations[alias]) {
+        return settings.organizations[alias];
+    }
+    return settings.defaults || null;
+}
+export function isProjectAllowed(projectKey, orgAlias) {
+    const settings = getEffectiveSettings(orgAlias);
+    if (!settings)
+        return false;
+    const isAllowed = settings['allowed-jira-projects'].some(p => {
         if (typeof p === 'string') {
             return p === 'all' || p === projectKey;
         }
@@ -118,16 +148,18 @@ export function isProjectAllowed(projectKey) {
     });
     return isAllowed;
 }
-export function isCommandAllowed(commandName, projectKey) {
-    const settings = loadSettings();
+export function isCommandAllowed(commandName, projectKey, orgAlias) {
     // about, auth, and settings are always allowed
     if (['about', 'auth', 'settings'].includes(commandName)) {
         return true;
     }
+    const settings = getEffectiveSettings(orgAlias);
+    if (!settings)
+        return false;
     if (projectKey) {
-        let project = settings.projects.find(p => typeof p !== 'string' && p.key === projectKey);
+        let project = settings['allowed-jira-projects'].find(p => typeof p !== 'string' && p.key === projectKey);
         if (!project) {
-            project = settings.projects.find(p => typeof p === 'string' && (p === 'all' || p === projectKey));
+            project = settings['allowed-jira-projects'].find(p => typeof p === 'string' && (p === 'all' || p === projectKey));
         }
         if (project && typeof project !== 'string' && project.commands) {
             return project.commands.includes(commandName);
@@ -135,32 +167,40 @@ export function isCommandAllowed(commandName, projectKey) {
     }
     else {
         // For visibility/global check: allowed if in global list OR in any project-specific list
-        const allowedGlobally = settings.commands.includes('all') || settings.commands.includes(commandName);
+        const allowedGlobally = settings['allowed-commands'].includes('all') || settings['allowed-commands'].includes(commandName);
         if (allowedGlobally) {
             return true;
         }
-        const allowedInAnyProject = settings.projects.some(p => typeof p !== 'string' && p.commands && p.commands.includes(commandName));
+        const allowedInAnyProject = settings['allowed-jira-projects'].some(p => typeof p !== 'string' && p.commands && p.commands.includes(commandName));
         if (allowedInAnyProject) {
             return true;
         }
         return false;
     }
-    if (settings.commands.includes('all')) {
+    if (settings['allowed-commands'].includes('all')) {
         return true;
     }
-    return settings.commands.includes(commandName);
+    return settings['allowed-commands'].includes(commandName);
 }
-export function getAllowedProjects() {
-    const settings = loadSettings();
-    return settings.projects;
+export function isConfluenceSpaceAllowed(spaceKey, orgAlias) {
+    const settings = getEffectiveSettings(orgAlias);
+    if (!settings)
+        return false;
+    return settings['allowed-confluence-spaces'].some(s => s === 'all' || s === spaceKey);
 }
-export function getAllowedCommands() {
-    const settings = loadSettings();
-    return settings.commands;
+export function getAllowedProjects(orgAlias) {
+    const settings = getEffectiveSettings(orgAlias);
+    return settings ? settings['allowed-jira-projects'] : [];
 }
-export function applyGlobalFilters(jql) {
-    const settings = loadSettings();
-    const allAllowed = settings.projects.some(p => p === 'all');
+export function getAllowedCommands(orgAlias) {
+    const settings = getEffectiveSettings(orgAlias);
+    return settings ? settings['allowed-commands'] : [];
+}
+export function applyGlobalFilters(jql, orgAlias) {
+    const settings = getEffectiveSettings(orgAlias);
+    if (!settings)
+        return jql;
+    const allAllowed = settings['allowed-jira-projects'].some(p => p === 'all');
     if (allAllowed) {
         return jql;
     }
@@ -172,7 +212,7 @@ export function applyGlobalFilters(jql) {
         filterPart = orderByMatch[1].trim();
         orderByPart = ` ORDER BY ${orderByMatch[2].trim()}`;
     }
-    const projectFilters = settings.projects.map(p => {
+    const projectFilters = settings['allowed-jira-projects'].map(p => {
         const key = typeof p === 'string' ? p : p.key;
         const projectJql = typeof p === 'string' ? null : p.filters?.jql;
         if (projectJql) {
@@ -190,14 +230,16 @@ export function applyGlobalFilters(jql) {
     const filterJql = filterPart.trim() ? ` AND (${filterPart})` : '';
     return `(${combinedProjectFilter})${filterJql}${orderByPart}`;
 }
-export function validateIssueAgainstFilters(issue, currentUserId) {
-    const settings = loadSettings();
+export function validateIssueAgainstFilters(issue, currentUserId, orgAlias) {
+    const settings = getEffectiveSettings(orgAlias);
+    if (!settings)
+        return false;
     const projectKey = issue.key.split('-')[0];
     // Find specific project config first
-    let project = settings.projects.find(p => typeof p !== 'string' && p.key === projectKey);
+    let project = settings['allowed-jira-projects'].find(p => typeof p !== 'string' && p.key === projectKey);
     // If not found, look for string match (exact project key or 'all')
     if (!project) {
-        project = settings.projects.find(p => typeof p === 'string' && (p === 'all' || p === projectKey));
+        project = settings['allowed-jira-projects'].find(p => typeof p === 'string' && (p === 'all' || p === projectKey));
     }
     if (!project) {
         return false;

package/dist/lib/validation.js

@@ -93,7 +93,15 @@ export const ProjectSettingSchema = z.union([
     z.string().trim().min(1),
     ProjectConfigSchema
 ]);
+export const OrganizationSettingsSchema = z.object({
+    'allowed-jira-projects': z.array(ProjectSettingSchema).nullish().transform(val => val || ['all']),
+    'allowed-commands': z.array(z.string()).nullish().transform(val => val || ['me', 'projects', 'task-with-details', 'run-jql', 'list-issue-types', 'project-statuses', 'create-task', 'list-colleagues', 'add-comment', 'add-label-to-issue', 'delete-label-from-issue', 'get-issue-statistics', 'get-person-worklog', 'organization', 'transition', 'update-description', 'confluence']),
+    'allowed-confluence-spaces': z.array(z.string()).nullish().transform(val => val || ['all']),
+});
 export const SettingsSchema = z.object({
-    projects: z.array(ProjectSettingSchema).nullish().transform(val => val || ['all']),
-    commands: z.array(z.string()).nullish().transform(val => val || ['me', 'projects', 'task-with-details', 'run-jql', 'list-issue-types', 'project-statuses', 'create-task', 'list-colleagues', 'add-comment', 'add-label-to-issue', 'delete-label-from-issue', 'get-issue-statistics', 'get-person-worklog', 'organization', 'transition', 'update-description', 'confl']),
+    defaults: OrganizationSettingsSchema.optional(),
+    organizations: z.record(z.string(), OrganizationSettingsSchema).optional(),
+    // Keep legacy fields for migration
+    projects: z.array(ProjectSettingSchema).optional(),
+    commands: z.array(z.string()).optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jira-ai",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "AI friendly Jira CLI to save context",
   "type": "module",
   "main": "dist/cli.js",