@girardmedia/bootspring 2.0.21 → 2.0.23

package/bin/bootspring.js

@@ -139,6 +139,11 @@ const COMMANDS = {
     description: 'Manage subscription and view usage',
     usage: 'bootspring billing [status|usage|upgrade|portal]'
   },
+  org: {
+    script: '../cli/org.js',
+    description: 'Manage organization policies and members',
+    usage: 'bootspring org [list|info|policy|members]'
+  },
   manager: {
     script: '../cli/manager.js',
     description: 'Overview of all projects with health scores',

package/cli/org.js

@@ -0,0 +1,474 @@
+/**
+ * Bootspring Organization Command
+ * Manage organization policies and members
+ *
+ * Commands:
+ *   list                  List your organizations
+ *   info [orgId]          Show organization details
+ *   policy get            Get current policy settings
+ *   policy set <profile>  Set policy profile (startup/regulated/enterprise)
+ *   policy scopes         List available policy scopes
+ *   members               List organization members
+ *   member <userId> policy  View/set member policy overrides
+ *
+ * @package bootspring
+ * @command org
+ */
+
+const utils = require('../core/utils');
+const auth = require('../core/auth');
+const apiClient = require('../core/api-client');
+const policies = require('../core/policies');
+const organizations = require('../core/organizations');
+const policyMatrix = require('../core/policy-matrix');
+
+/**
+ * Run the org command
+ */
+async function run(args = []) {
+  const subcommand = args[0] || 'list';
+
+  switch (subcommand) {
+    case 'list':
+      return listOrganizations();
+    case 'info':
+      return showOrgInfo(args[1]);
+    case 'policy':
+      return handlePolicyCommand(args.slice(1));
+    case 'members':
+      return listMembers(args[1]);
+    case 'member':
+      return handleMemberCommand(args.slice(1));
+    case 'help':
+    case '--help':
+    case '-h':
+      return showHelp();
+    default:
+      console.log(`${utils.COLORS.red}Unknown command: ${subcommand}${utils.COLORS.reset}`);
+      showHelp();
+      return 1;
+  }
+}
+
+/**
+ * List user's organizations
+ */
+async function listOrganizations() {
+  if (!auth.isAuthenticated()) {
+    console.log(`${utils.COLORS.yellow}Not authenticated. Run: bootspring auth login${utils.COLORS.reset}`);
+    return 1;
+  }
+
+  const spinner = utils.createSpinner('Fetching organizations...').start();
+
+  try {
+    const orgs = await apiClient.listOrganizations();
+
+    if (!orgs || orgs.length === 0) {
+      spinner.info('No organizations found');
+      console.log(`\n${utils.COLORS.dim}Create an organization at bootspring.com/dashboard${utils.COLORS.reset}`);
+      return 0;
+    }
+
+    spinner.succeed(`Found ${orgs.length} organization(s)`);
+
+    console.log(`\n${utils.COLORS.bold}Your Organizations:${utils.COLORS.reset}\n`);
+
+    for (const org of orgs) {
+      const tierBadge = getTierBadge(org.tier);
+      const profileBadge = getProfileBadge(org.policyProfile);
+      console.log(`  ${utils.COLORS.cyan}${org.name}${utils.COLORS.reset} ${tierBadge} ${profileBadge}`);
+      console.log(`  ${utils.COLORS.dim}ID: ${org.id}${utils.COLORS.reset}`);
+      console.log(`  ${utils.COLORS.dim}Members: ${org.memberCount || '?'}${utils.COLORS.reset}`);
+      console.log();
+    }
+
+    return 0;
+  } catch (error) {
+    spinner.fail(`Failed to fetch organizations: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Show organization info
+ */
+async function showOrgInfo(orgId) {
+  const resolvedOrgId = orgId || process.env.BOOTSPRING_ORG_ID || auth.getCredentials()?.orgId;
+
+  if (!resolvedOrgId) {
+    console.log(`${utils.COLORS.yellow}No organization specified.${utils.COLORS.reset}`);
+    console.log(`Usage: bootspring org info <orgId>`);
+    console.log(`Or set BOOTSPRING_ORG_ID environment variable`);
+    return 1;
+  }
+
+  const spinner = utils.createSpinner('Fetching organization...').start();
+
+  try {
+    const org = await apiClient.getOrganization(resolvedOrgId);
+    spinner.succeed('Organization loaded');
+
+    console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}${org.name}${utils.COLORS.reset}
+${utils.COLORS.dim}${'─'.repeat(50)}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Details:${utils.COLORS.reset}
+  ID:       ${org.id}
+  Tier:     ${getTierBadge(org.tier)}
+  Profile:  ${getProfileBadge(org.policyProfile)}
+  Created:  ${new Date(org.createdAt).toLocaleDateString()}
+
+${utils.COLORS.bold}Policy:${utils.COLORS.reset}
+  External Skills:  ${org.policy?.allowExternalSkills ? '✓ Allowed' : '✗ Blocked'}
+  Blocked Workflows: ${org.policy?.blockedWorkflows?.length || 0}
+
+${utils.COLORS.bold}Members:${utils.COLORS.reset} ${org.memberCount || org.members?.length || '?'}
+`);
+
+    if (org.members && org.members.length > 0) {
+      console.log(`${utils.COLORS.bold}Member List:${utils.COLORS.reset}`);
+      for (const member of org.members.slice(0, 10)) {
+        const roleBadge = getRoleBadge(member.role);
+        console.log(`  ${member.email || member.userId} ${roleBadge}`);
+      }
+      if (org.members.length > 10) {
+        console.log(`  ${utils.COLORS.dim}... and ${org.members.length - 10} more${utils.COLORS.reset}`);
+      }
+    }
+
+    return 0;
+  } catch (error) {
+    spinner.fail(`Failed to fetch organization: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Handle policy subcommands
+ */
+async function handlePolicyCommand(args) {
+  const action = args[0] || 'get';
+
+  switch (action) {
+    case 'get':
+      return showPolicy(args[1]);
+    case 'set':
+      return setPolicy(args[1], args[2]);
+    case 'scopes':
+      return showScopes();
+    case 'profiles':
+      return showProfiles();
+    default:
+      console.log(`${utils.COLORS.red}Unknown policy action: ${action}${utils.COLORS.reset}`);
+      console.log('Available: get, set, scopes, profiles');
+      return 1;
+  }
+}
+
+/**
+ * Show current policy
+ */
+async function showPolicy(orgId) {
+  try {
+    const summary = await organizations.getOrgPolicySummary({ orgId });
+
+    if (!summary.hasOrg) {
+      // Show user-level policy
+      const profile = policies.resolvePolicyProfile();
+      const policy = policies.getPolicyProfile(profile);
+
+      console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Current Policy (User-Level)${utils.COLORS.reset}
+${utils.COLORS.dim}${'─'.repeat(50)}${utils.COLORS.reset}
+
+  Profile:           ${getProfileBadge(profile)}
+  External Skills:   ${policy.allowExternalSkills ? '✓ Allowed' : '✗ Blocked'}
+  Blocked Workflows: ${policy.blockedWorkflows.length > 0 ? policy.blockedWorkflows.join(', ') : 'None'}
+
+${utils.COLORS.dim}No organization context. Set BOOTSPRING_ORG_ID for org-level policy.${utils.COLORS.reset}
+`);
+      return 0;
+    }
+
+    console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Organization Policy${utils.COLORS.reset}
+${utils.COLORS.dim}${'─'.repeat(50)}${utils.COLORS.reset}
+
+  Organization: ${summary.orgName || summary.orgId}
+  Tier:         ${getTierBadge(summary.tier)}
+  Profile:      ${getProfileBadge(summary.profile)}
+  Your Role:    ${getRoleBadge(summary.role)}
+
+${utils.COLORS.bold}Scope Summary:${utils.COLORS.reset}
+  Allowed Scopes:  ${utils.COLORS.green}${summary.allowedScopes}${utils.COLORS.reset}
+  Blocked Scopes:  ${utils.COLORS.red}${summary.blockedScopes}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Limits:${utils.COLORS.reset}
+  Skills/Day:      ${formatLimit(summary.limits.skillsPerDay)}
+  Workflows/Day:   ${formatLimit(summary.limits.workflowsPerDay)}
+  Agent Calls/Day: ${formatLimit(summary.limits.agentInvocationsPerDay)}
+  Team Members:    ${formatLimit(summary.limits.teamMembers)}
+
+${summary.overrides.length > 0 ? `${utils.COLORS.bold}Active Overrides:${utils.COLORS.reset} ${summary.overrides.join(', ')}` : ''}
+`);
+
+    return 0;
+  } catch (error) {
+    console.log(`${utils.COLORS.red}Failed to get policy: ${error.message}${utils.COLORS.reset}`);
+    return 1;
+  }
+}
+
+/**
+ * Set policy profile
+ */
+async function setPolicy(profile, orgId) {
+  if (!profile) {
+    console.log(`${utils.COLORS.yellow}Please specify a profile: startup, regulated, or enterprise${utils.COLORS.reset}`);
+    return 1;
+  }
+
+  const validProfiles = ['startup', 'regulated', 'enterprise'];
+  if (!validProfiles.includes(profile.toLowerCase())) {
+    console.log(`${utils.COLORS.red}Invalid profile: ${profile}${utils.COLORS.reset}`);
+    console.log(`Valid profiles: ${validProfiles.join(', ')}`);
+    return 1;
+  }
+
+  const resolvedOrgId = orgId || process.env.BOOTSPRING_ORG_ID;
+
+  if (!resolvedOrgId) {
+    // Set user-level via env var hint
+    console.log(`
+${utils.COLORS.yellow}No organization specified.${utils.COLORS.reset}
+
+To set user-level policy, add to your environment:
+  ${utils.COLORS.cyan}export BOOTSPRING_POLICY_PROFILE=${profile}${utils.COLORS.reset}
+
+To set org-level policy, specify an org ID:
+  ${utils.COLORS.cyan}bootspring org policy set ${profile} <orgId>${utils.COLORS.reset}
+`);
+    return 0;
+  }
+
+  const spinner = utils.createSpinner(`Setting policy to "${profile}"...`).start();
+
+  try {
+    await apiClient.updateOrgPolicy(resolvedOrgId, { policyProfile: profile });
+    organizations.clearOrgCache(resolvedOrgId);
+    spinner.succeed(`Policy updated to "${profile}"`);
+    return 0;
+  } catch (error) {
+    spinner.fail(`Failed to update policy: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Show available scopes
+ */
+function showScopes() {
+  const scopes = policies.getPolicyScopes();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Policy Scopes${utils.COLORS.reset}
+${utils.COLORS.dim}${'─'.repeat(50)}${utils.COLORS.reset}
+`);
+
+  for (const [category, categoryScopes] of Object.entries(scopes)) {
+    console.log(`${utils.COLORS.bold}${category}:${utils.COLORS.reset}`);
+    for (const [name, scope] of Object.entries(categoryScopes)) {
+      console.log(`  ${utils.COLORS.cyan}${scope}${utils.COLORS.reset} ${utils.COLORS.dim}(${name})${utils.COLORS.reset}`);
+    }
+    console.log();
+  }
+
+  return 0;
+}
+
+/**
+ * Show available profiles
+ */
+function showProfiles() {
+  const profiles = policies.listPolicyProfiles();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Policy Profiles${utils.COLORS.reset}
+${utils.COLORS.dim}${'─'.repeat(50)}${utils.COLORS.reset}
+`);
+
+  for (const profile of profiles) {
+    console.log(`  ${getProfileBadge(profile.id)} ${utils.COLORS.dim}(${profile.tier} tier+)${utils.COLORS.reset}`);
+    console.log(`  ${utils.COLORS.dim}${profile.description}${utils.COLORS.reset}`);
+    console.log();
+  }
+
+  return 0;
+}
+
+/**
+ * List organization members
+ */
+async function listMembers(orgId) {
+  const resolvedOrgId = orgId || process.env.BOOTSPRING_ORG_ID;
+
+  if (!resolvedOrgId) {
+    console.log(`${utils.COLORS.yellow}No organization specified.${utils.COLORS.reset}`);
+    return 1;
+  }
+
+  const spinner = utils.createSpinner('Fetching members...').start();
+
+  try {
+    const members = await apiClient.listOrgMembers(resolvedOrgId);
+    spinner.succeed(`Found ${members.length} member(s)`);
+
+    console.log(`\n${utils.COLORS.bold}Organization Members:${utils.COLORS.reset}\n`);
+
+    for (const member of members) {
+      const roleBadge = getRoleBadge(member.role);
+      const hasOverrides = member.policyOverrides && Object.keys(member.policyOverrides).length > 0;
+      console.log(`  ${member.email || member.userId} ${roleBadge}${hasOverrides ? ' (custom policy)' : ''}`);
+    }
+
+    return 0;
+  } catch (error) {
+    spinner.fail(`Failed to fetch members: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Handle member subcommands
+ */
+async function handleMemberCommand(args) {
+  const userId = args[0];
+  const action = args[1] || 'info';
+
+  if (!userId) {
+    console.log(`${utils.COLORS.yellow}Please specify a user ID${utils.COLORS.reset}`);
+    return 1;
+  }
+
+  switch (action) {
+    case 'info':
+    case 'policy':
+      return showMemberPolicy(userId, args[2]);
+    default:
+      console.log(`${utils.COLORS.red}Unknown member action: ${action}${utils.COLORS.reset}`);
+      return 1;
+  }
+}
+
+/**
+ * Show member policy
+ */
+async function showMemberPolicy(userId, orgId) {
+  const resolvedOrgId = orgId || process.env.BOOTSPRING_ORG_ID;
+
+  if (!resolvedOrgId) {
+    console.log(`${utils.COLORS.yellow}No organization specified.${utils.COLORS.reset}`);
+    return 1;
+  }
+
+  const spinner = utils.createSpinner('Fetching member policy...').start();
+
+  try {
+    const policy = await apiClient.getMemberPolicy(resolvedOrgId, userId);
+    spinner.succeed('Member policy loaded');
+
+    console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Member Policy${utils.COLORS.reset}
+${utils.COLORS.dim}${'─'.repeat(50)}${utils.COLORS.reset}
+
+  User: ${userId}
+  Role: ${getRoleBadge(policy.role)}
+
+${utils.COLORS.bold}Policy Overrides:${utils.COLORS.reset}
+  ${policy.overrides && Object.keys(policy.overrides).length > 0
+    ? JSON.stringify(policy.overrides, null, 2).split('\n').join('\n  ')
+    : 'No custom overrides (using org defaults)'}
+`);
+
+    return 0;
+  } catch (error) {
+    spinner.fail(`Failed to fetch member policy: ${error.message}`);
+    return 1;
+  }
+}
+
+// Helper functions
+
+function getTierBadge(tier) {
+  const badges = {
+    free: `${utils.COLORS.dim}[free]${utils.COLORS.reset}`,
+    pro: `${utils.COLORS.blue}[pro]${utils.COLORS.reset}`,
+    team: `${utils.COLORS.green}[team]${utils.COLORS.reset}`,
+    enterprise: `${utils.COLORS.magenta}[enterprise]${utils.COLORS.reset}`
+  };
+  return badges[tier] || `[${tier}]`;
+}
+
+function getProfileBadge(profile) {
+  const badges = {
+    startup: `${utils.COLORS.cyan}startup${utils.COLORS.reset}`,
+    regulated: `${utils.COLORS.yellow}regulated${utils.COLORS.reset}`,
+    enterprise: `${utils.COLORS.magenta}enterprise${utils.COLORS.reset}`
+  };
+  return badges[profile] || profile;
+}
+
+function getRoleBadge(role) {
+  const badges = {
+    owner: `${utils.COLORS.red}(owner)${utils.COLORS.reset}`,
+    admin: `${utils.COLORS.yellow}(admin)${utils.COLORS.reset}`,
+    member: `${utils.COLORS.dim}(member)${utils.COLORS.reset}`,
+    viewer: `${utils.COLORS.dim}(viewer)${utils.COLORS.reset}`
+  };
+  return badges[role] || `(${role})`;
+}
+
+function formatLimit(value) {
+  if (value === -1) return `${utils.COLORS.green}Unlimited${utils.COLORS.reset}`;
+  if (value === undefined) return `${utils.COLORS.dim}N/A${utils.COLORS.reset}`;
+  return value.toLocaleString();
+}
+
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Organization${utils.COLORS.reset}
+${utils.COLORS.dim}Manage organization policies and members${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring org <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}                    List your organizations
+  ${utils.COLORS.cyan}info${utils.COLORS.reset} [orgId]            Show organization details
+  ${utils.COLORS.cyan}policy get${utils.COLORS.reset}              Get current policy settings
+  ${utils.COLORS.cyan}policy set <profile>${utils.COLORS.reset}    Set policy profile
+  ${utils.COLORS.cyan}policy scopes${utils.COLORS.reset}           List available policy scopes
+  ${utils.COLORS.cyan}policy profiles${utils.COLORS.reset}         List policy profiles
+  ${utils.COLORS.cyan}members${utils.COLORS.reset} [orgId]         List organization members
+  ${utils.COLORS.cyan}member <userId> policy${utils.COLORS.reset}  View member policy overrides
+
+${utils.COLORS.bold}Policy Profiles:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}startup${utils.COLORS.reset}      Permissive policy for fast iteration
+  ${utils.COLORS.cyan}regulated${utils.COLORS.reset}    Compliance-focused, external skills blocked
+  ${utils.COLORS.cyan}enterprise${utils.COLORS.reset}   Full control with SSO and audit
+
+${utils.COLORS.bold}Environment:${utils.COLORS.reset}
+  BOOTSPRING_ORG_ID             Default organization ID
+  BOOTSPRING_POLICY_PROFILE     User-level policy profile
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring org list
+  bootspring org info org_abc123
+  bootspring org policy get
+  bootspring org policy set regulated
+  bootspring org members
+`);
+}
+
+module.exports = { run };

package/cli/preseed/index.js

@@ -0,0 +1,16 @@
+/**
+ * Preseed Module Index
+ * Re-exports all preseed submodules
+ * @package bootspring
+ */
+
+const interactive = require('./interactive');
+const templates = require('./templates');
+
+module.exports = {
+  interactive,
+  templates,
+  // Re-export commonly used functions at top level
+  ...interactive,
+  ...templates
+};

package/cli/preseed/interactive.js

@@ -0,0 +1,143 @@
+/**
+ * Interactive Helpers
+ * Readline and prompting utilities for preseed wizard
+ * @package bootspring
+ */
+
+const readline = require('readline');
+const utils = require('../../core/utils');
+
+/**
+ * Create readline interface
+ * @returns {readline.Interface}
+ */
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Ask a text question
+ * @param {readline.Interface} rl - readline interface
+ * @param {string} question - the question to ask
+ * @param {string} defaultValue - default value if empty
+ * @returns {Promise<string>}
+ */
+function askText(rl, question, defaultValue = '') {
+  const prompt = defaultValue
+    ? `${question} ${utils.COLORS.dim}[${defaultValue}]${utils.COLORS.reset}: `
+    : `${question}: `;
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+/**
+ * Ask a multi-line text question
+ * @param {readline.Interface} rl - readline interface
+ * @param {string} question - the question to ask
+ * @param {string} hint - hint text
+ * @returns {Promise<string>}
+ */
+function askMultiLine(rl, question, hint = 'Enter text (empty line to finish)') {
+  return new Promise((resolve) => {
+    console.log(`\n${utils.COLORS.bold}${question}${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}${hint}${utils.COLORS.reset}`);
+
+    const lines = [];
+    const onLine = (line) => {
+      if (line.trim() === '') {
+        rl.removeListener('line', onLine);
+        resolve(lines.join('\n'));
+      } else {
+        lines.push(line);
+      }
+    };
+    rl.on('line', onLine);
+  });
+}
+
+/**
+ * Ask a list question (comma-separated)
+ * @param {readline.Interface} rl - readline interface
+ * @param {string} question - the question to ask
+ * @param {string} hint - hint text
+ * @returns {Promise<string[]>}
+ */
+function askList(rl, question, hint = 'Enter comma-separated values') {
+  return new Promise((resolve) => {
+    console.log(`\n${utils.COLORS.bold}${question}${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}${hint}${utils.COLORS.reset}`);
+
+    rl.question('> ', (answer) => {
+      const items = answer
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+      resolve(items);
+    });
+  });
+}
+
+/**
+ * Ask a choice question
+ * @param {readline.Interface} rl - readline interface
+ * @param {string} question - the question to ask
+ * @param {Array} options - array of options (strings or {label, value, description})
+ * @param {number} defaultIndex - default selected index
+ * @returns {Promise<string>}
+ */
+function askChoice(rl, question, options, defaultIndex = 0) {
+  return new Promise((resolve) => {
+    console.log(`\n${utils.COLORS.bold}${question}${utils.COLORS.reset}`);
+
+    options.forEach((opt, i) => {
+      const marker = i === defaultIndex
+        ? `${utils.COLORS.cyan}>${utils.COLORS.reset}`
+        : ' ';
+      const label = typeof opt === 'object' ? opt.label : opt;
+      const desc = typeof opt === 'object' && opt.description
+        ? ` ${utils.COLORS.dim}- ${opt.description}${utils.COLORS.reset}`
+        : '';
+      console.log(`  ${marker} ${i + 1}. ${label}${desc}`);
+    });
+
+    rl.question(`\n${utils.COLORS.dim}Select [1-${options.length}]${utils.COLORS.reset}: `, (answer) => {
+      const index = parseInt(answer, 10) - 1;
+      const selectedIndex = (index >= 0 && index < options.length) ? index : defaultIndex;
+      const selected = options[selectedIndex];
+      resolve(typeof selected === 'object' ? selected.value : selected);
+    });
+  });
+}
+
+/**
+ * Display section header
+ * @param {number} number - current step number
+ * @param {number} total - total steps
+ * @param {string} title - section title
+ * @param {string} description - section description
+ */
+function displaySection(number, total, title, description) {
+  console.log('\n');
+  console.log(`${utils.COLORS.cyan}${'━'.repeat(60)}${utils.COLORS.reset}`);
+  console.log(`${utils.COLORS.bold}Step ${number}/${total}: ${title}${utils.COLORS.reset}`);
+  if (description) {
+    console.log(`${utils.COLORS.dim}${description}${utils.COLORS.reset}`);
+  }
+  console.log(`${utils.COLORS.cyan}${'━'.repeat(60)}${utils.COLORS.reset}`);
+}
+
+module.exports = {
+  createInterface,
+  askText,
+  askMultiLine,
+  askList,
+  askChoice,
+  displaySection
+};