@juspay/shooter 1.4.0 → 1.6.0

package/scripts/setup.cjs

@@ -9,7 +9,6 @@ const { execSync, spawn } = require('child_process');
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
-const http = require('http');
 
 // ── ANSI helpers ─────────────────────────────────────────────────────
 const C = {
@@ -52,10 +51,28 @@ function escapeForDoubleQuotedShell(s) {
   return s.replace(/[\\"$`]/g, '\\$&');
 }
 
-// ── Secure key generator ─────────────────────────────────────────────
-// Produces a 256-bit random hex key (64 characters).
-function generateSecureKey() {
-  return crypto.randomBytes(32).toString('hex');
+// ── API key generator ────────────────────────────────────────────────
+// Produces a readable key: <machinename><4 random hex chars>
+// e.g. "sachinsharma567f"
+// Easy to recognise, type, and remember — still unique per install.
+function generateApiKey() {
+  const os = require('os');
+  // Take only the letters-only leading portion of the hostname — strips
+  // device serial suffixes like HCW39CV9MH which always contain digits.
+  const name =
+    os
+      .hostname()
+      .toLowerCase()
+      .replace(/\.local$/, '') // strip macOS .local suffix
+      .replace(/[^a-z0-9]/g, ' ') // turn separators into spaces
+      .trim()
+      .split(' ')
+      .filter((p) => /^[a-z]+$/.test(p)) // keep only pure-letter segments
+      .join('')
+      .slice(0, 20) || 'shooter';
+
+  const suffix = crypto.randomBytes(16).toString('hex'); // 128 bits of entropy
+  return `${name}-${suffix}`;
 }
 
 // ── Globals ──────────────────────────────────────────────────────────
@@ -63,9 +80,64 @@ const ROOT = process.env.SHOOTER_PKG_ROOT || path.resolve(__dirname, '..');
 const SHOOTER_HOME = process.env.SHOOTER_HOME || path.join(require('os').homedir(), '.shooter');
 const DOT_ENV_PATH = path.join(SHOOTER_HOME, '.env');
 const AUTO_MODE = process.argv.includes('--auto');
+const PUSH_MODE = process.argv.includes('--push');
 
 let rl; // readline interface — created in main()
 
+// ── AI Provider Registry ─────────────────────────────────────────────
+const PROVIDER_REGISTRY = [
+  {
+    envKeys: ['GOOGLE_AI_API_KEY'],
+    hint: 'Get free at https://aistudio.google.com/apikey',
+    id: 'google-ai',
+    label: 'Google AI (Gemini)',
+  },
+  {
+    envKeys: ['ANTHROPIC_API_KEY'],
+    hint: 'Get at https://console.anthropic.com',
+    id: 'anthropic',
+    label: 'Anthropic (Claude)',
+  },
+  {
+    envKeys: ['OPENAI_API_KEY'],
+    hint: 'Get at https://platform.openai.com/api-keys',
+    id: 'openai',
+    label: 'OpenAI (GPT)',
+  },
+  {
+    envKeys: ['MISTRAL_API_KEY'],
+    hint: 'Get at https://console.mistral.ai',
+    id: 'mistral',
+    label: 'Mistral',
+  },
+  {
+    extraKeys: ['LITELLM_MODEL'],
+    envKeys: ['LITELLM_API_KEY', 'LITELLM_BASE_URL'],
+    hint: 'Local OpenAI-compatible proxy',
+    id: 'litellm',
+    label: 'LiteLLM (local)',
+  },
+];
+
+const AI_ENV_KEYS = [
+  'ANTHROPIC_API_KEY',
+  'GOOGLE_AI_API_KEY',
+  'LITELLM_API_KEY',
+  'LITELLM_BASE_URL',
+  'LITELLM_MODEL',
+  'MISTRAL_API_KEY',
+  'NEUROLINK_PROVIDER',
+  'OPENAI_API_KEY',
+];
+
+// ── Auto-incrementing step counter ──────────────────────────────────
+let _stepNum = 0;
+let _totalSteps = 5;
+function step(label) {
+  _stepNum++;
+  console.log(`\n${C.blue}[${_stepNum}/${_totalSteps}] ${label}${C.reset}\n`);
+}
+
 // ── Readline helpers ─────────────────────────────────────────────────
 
 function ask(question) {
@@ -97,18 +169,6 @@ async function askRequired(question, validator) {
   }
 }
 
-async function askMultiline(prompt) {
-  console.log(cyan(prompt));
-  console.log(dim('  Paste the content, then press Enter on an empty line to finish:'));
-  const lines = [];
-  while (true) {
-    const line = await ask('');
-    if (line === '') break;
-    lines.push(line);
-  }
-  return lines.join('\n');
-}
-
 // ── Banner ───────────────────────────────────────────────────────────
 
 function printBanner() {
@@ -120,7 +180,7 @@ function printBanner() {
   console.log(`${C.cyan}${C.bold} |____/|_| |_|\\___/ \\___/ \\__\\___|_|   ${C.reset}`);
   console.log('');
   console.log(bold('  Interactive Setup Wizard'));
-  console.log(dim('  Push notifications for your coding sessions'));
+  console.log(dim('  Remote terminals, session viewer & push notifications'));
   console.log('');
   console.log(dim('  ─────────────────────────────────────────'));
   console.log('');
@@ -129,7 +189,7 @@ function printBanner() {
 // ── Prerequisite checks ─────────────────────────────────────────────
 
 function checkPrerequisites() {
-  console.log(bold('1. Checking prerequisites...\n'));
+  step('Checking prerequisites...');
 
   // Node.js version
   const nodeVersion = process.versions.node;
@@ -203,77 +263,147 @@ function validateEmail(email) {
   return null;
 }
 
-// ── Collect configuration ────────────────────────────────────────────
-
-async function collectConfig() {
-  const config = {
-    apiKey: '',
-    // iOS APNs
-    wantIos: false,
-    apnsKey: '',
-    apnsKeyId: '',
-    apnsTeamId: '',
-    apnsBundleId: '',
-    apnsProduction: false,
-    deviceToken: '',
-    // Android FCM
-    wantAndroid: false,
-    fcmProjectId: '',
-    fcmClientEmail: '',
-    fcmPrivateKey: '',
-    androidDeviceToken: '',
-  };
+// ── Collect AI Provider Config ───────────────────────────────────────
+async function collectAIConfig(config) {
+  step('AI-Powered Features (Optional)');
+  console.log('');
+  console.log('  Shooter uses NeuroLink to generate AI summaries of your coding sessions.');
+  console.log('  You can configure one or more AI providers.');
+  console.log('');
 
-  // ── Auto mode: reuse existing key or generate new, skip push config ──
   if (AUTO_MODE) {
-    console.log(bold('2. Auto-configuring...\n'));
+    console.log(dim('  Skipping AI provider configuration in --auto mode.'));
+    console.log('');
+    return;
+  }
 
-    // Preserve existing API_KEY if .env already exists
-    if (fs.existsSync(DOT_ENV_PATH)) {
-      const existing = fs.readFileSync(DOT_ENV_PATH, 'utf-8');
-      const match = existing.match(/^API_KEY=(.+)$/m);
-      if (match && match[1]) {
-        config.apiKey = match[1];
-        const maskedKey = mask(config.apiKey);
-        console.log(green(`  Existing API key preserved: ${maskedKey}`));
-        console.log(dim('  Push notifications skipped (run "shooter setup" to configure later)'));
-        console.log('');
-        return config;
+  const wantAI = await confirm('Configure AI providers?');
+  if (!wantAI) {
+    console.log('  Skipped — summaries will use basic text fallback.');
+    return;
+  }
+
+  console.log('');
+  console.log('  Available providers:');
+  PROVIDER_REGISTRY.forEach((p, i) => {
+    console.log(`    ${i + 1}. ${p.label}`);
+  });
+  console.log(`    ${PROVIDER_REGISTRY.length + 1}. Skip`);
+  console.log('');
+
+  let configureMore = true;
+  while (configureMore) {
+    const choice = await askRequired(
+      `Choose provider (1-${PROVIDER_REGISTRY.length + 1})`,
+      (val) => {
+        const n = parseInt(val, 10);
+        return n >= 1 && n <= PROVIDER_REGISTRY.length + 1
+          ? null
+          : `Enter a number 1-${PROVIDER_REGISTRY.length + 1}`;
       }
+    );
+
+    const idx = parseInt(choice, 10) - 1;
+    if (idx >= PROVIDER_REGISTRY.length) {
+      break;
     }
 
-    config.apiKey = generateSecureKey();
-    const maskedKey = mask(config.apiKey);
-    console.log(green(`  API key generated: ${maskedKey}`));
-    console.log(dim('  Push notifications skipped (run "shooter setup" to configure later)'));
+    const provider = PROVIDER_REGISTRY[idx];
+    console.log(`  ${provider.hint}`);
+
+    for (const envKey of provider.envKeys) {
+      const value = await askRequired(`${envKey}`, (val) =>
+        val.length > 10 ? null : 'Key seems too short'
+      );
+      config[envKey] = value;
+    }
+
+    // Extra optional keys (e.g., LITELLM_MODEL)
+    if (provider.extraKeys) {
+      for (const envKey of provider.extraKeys) {
+        const value = await ask(`${envKey} (Enter to skip)`);
+        if (value) {
+          config[envKey] = value;
+        }
+      }
+    }
+
+    // Set as preferred provider if first one configured
+    if (!config.NEUROLINK_PROVIDER) {
+      config.NEUROLINK_PROVIDER = provider.id;
+    }
+
+    console.log(`  ✓ ${provider.label} configured`);
     console.log('');
-    return config;
-  }
 
-  // ── API Key ──────────────────────────────────────────────────────
-  console.log(bold('2. Server authentication\n'));
-  const apiKeyAnswer = await ask(`  API_KEY ${dim('(press Enter to auto-generate)')}: `);
-  if (apiKeyAnswer) {
-    config.apiKey = apiKeyAnswer;
-  } else {
-    config.apiKey = generateSecureKey();
-    const maskedKey = mask(config.apiKey);
-    console.log(green(`  Generated API key: ${maskedKey}`));
-    console.log(dim('  (Saved to ~/.shooter/.env)'));
+    configureMore = await confirm('Configure another provider?');
   }
-  console.log('');
+}
+
+// ── Collect configuration ────────────────────────────────────────────
 
+// ── Collect push notification config (separate flow) ────────────────
+
+async function collectPushConfig(config) {
   // ── iOS Push Notifications ───────────────────────────────────────
-  console.log(bold('3. iOS Push Notifications\n'));
-  config.wantIos = await confirm('  Do you want iOS push notifications?');
+  console.log(bold('  iOS Push Notifications\n'));
+  config.wantIos = await confirm('  Configure iOS push notifications?');
 
   if (config.wantIos) {
     console.log('');
 
-    // APNs key (.p8)
-    config.apnsKey = await askMultiline('  APNS_KEY (.p8 private key contents):');
-    if (!config.apnsKey.includes('BEGIN PRIVATE KEY')) {
-      console.log(yellow('  Warning: Key does not look like a .p8 file. Continuing anyway.'));
+    // APNs key (.p8) — accept file path or pasted content, with retry on invalid input
+    async function askForP8Key() {
+      const apnsKeyInput = await askRequired(`  APNS_KEY (.p8 file path or paste key): `, (val) => {
+        if (!val) return 'APNs key is required.';
+        return null;
+      });
+
+      let key;
+
+      // Check if input is a file path
+      if (fs.existsSync(apnsKeyInput)) {
+        try {
+          key = fs.readFileSync(apnsKeyInput, 'utf-8').trim();
+          console.log(green(`  Read key from ${apnsKeyInput}`));
+        } catch (err) {
+          console.log(red(`  Could not read file: ${err.message}`));
+          process.exit(1);
+        }
+      } else if (apnsKeyInput.includes('BEGIN PRIVATE KEY')) {
+        // User pasted inline content
+        key = apnsKeyInput;
+      } else {
+        // Might be a partial path or multiline paste — try multiline
+        console.log(yellow('  Input does not look like a file path or key.'));
+        console.log(
+          dim('  Paste the full .p8 key contents (press Enter on empty line to finish):')
+        );
+        const lines = [apnsKeyInput];
+        while (true) {
+          const line = await ask('');
+          if (line === '') break;
+          lines.push(line);
+        }
+        key = lines.join('\n');
+      }
+
+      if (!key.includes('BEGIN PRIVATE KEY')) {
+        console.log(yellow('  Warning: File does not appear to be a valid .p8 private key.'));
+        const retry = await ask(cyan('  Re-enter path? [Y/n]: '));
+        if (retry.toLowerCase() !== 'n') {
+          return askForP8Key(); // Recursive retry
+        }
+        console.log(yellow('  Skipping APNs configuration.'));
+        return null;
+      }
+
+      return key;
+    }
+
+    config.apnsKey = await askForP8Key();
+    if (!config.apnsKey) {
+      config.wantIos = false;
     }
     console.log('');
 
@@ -302,15 +432,37 @@ async function collectConfig() {
   console.log('');
 
   // ── Android Push Notifications ───────────────────────────────────
-  console.log(bold('4. Android Push Notifications\n'));
-  config.wantAndroid = await confirm('  Do you want Android push notifications?');
+  console.log(bold('  Android Push Notifications\n'));
+  config.wantAndroid = await confirm('  Configure Android push notifications?');
 
   if (config.wantAndroid) {
     console.log('');
     config.fcmProjectId = await askRequired('  FCM_PROJECT_ID: ');
     config.fcmClientEmail = await askRequired('  FCM_CLIENT_EMAIL: ', validateEmail);
 
-    config.fcmPrivateKey = await askMultiline('  FCM_PRIVATE_KEY (service account private key):');
+    const fcmKeyInput = await askRequired('  FCM_PRIVATE_KEY (file path or paste key): ');
+
+    if (fs.existsSync(fcmKeyInput)) {
+      try {
+        config.fcmPrivateKey = fs.readFileSync(fcmKeyInput, 'utf-8').trim();
+        console.log(green(`  Read key from ${fcmKeyInput}`));
+      } catch (err) {
+        console.log(red(`  Could not read file: ${err.message}`));
+        process.exit(1);
+      }
+    } else if (fcmKeyInput.includes('BEGIN')) {
+      config.fcmPrivateKey = fcmKeyInput;
+    } else {
+      console.log(dim('  Paste the full private key (press Enter on empty line to finish):'));
+      const lines = [fcmKeyInput];
+      while (true) {
+        const line = await ask('');
+        if (line === '') break;
+        lines.push(line);
+      }
+      config.fcmPrivateKey = lines.join('\n');
+    }
+
     if (!config.fcmPrivateKey.includes('BEGIN')) {
       console.log(
         yellow('  Warning: Key does not look like a PEM private key. Continuing anyway.')
@@ -326,6 +478,160 @@ async function collectConfig() {
     }
   }
   console.log('');
+}
+
+// ── Load existing AI config from .env (preserve during re-run) ──────────
+
+function loadExistingAIConfig(config) {
+  if (!fs.existsSync(DOT_ENV_PATH)) return;
+  const existing = fs.readFileSync(DOT_ENV_PATH, 'utf-8');
+
+  const get = (key) => {
+    const m = existing.match(new RegExp(`^${key}=["']?(.+?)["']?$`, 'm'));
+    return m ? m[1] : '';
+  };
+
+  for (const key of AI_ENV_KEYS) {
+    const value = get(key);
+    if (value) {
+      config[key] = value;
+    }
+  }
+}
+
+// ── Load existing push config from .env (preserve during non-push setup) ──
+
+function loadExistingPushConfig(config) {
+  if (!fs.existsSync(DOT_ENV_PATH)) return;
+  const existing = fs.readFileSync(DOT_ENV_PATH, 'utf-8');
+
+  const get = (key) => {
+    const m = existing.match(new RegExp(`^${key}=["']?(.+?)["']?$`, 'm'));
+    return m ? m[1] : '';
+  };
+
+  // Preserve iOS config if it was previously set
+  const apnsKeyId = get('APNS_KEY_ID');
+  if (apnsKeyId) {
+    config.wantIos = true;
+    // Read the raw APNS_KEY (may have escaped newlines)
+    const rawApnsKey = get('APNS_KEY');
+    config.apnsKey = rawApnsKey ? rawApnsKey.replace(/\\n/g, '\n') : '';
+    config.apnsKeyId = apnsKeyId;
+    config.apnsTeamId = get('APNS_TEAM_ID');
+    config.apnsBundleId = get('APNS_BUNDLE_ID');
+    config.apnsProduction = get('APNS_PRODUCTION') === 'true';
+    config.deviceToken = get('DEVICE_TOKEN');
+  }
+
+  // Preserve Android config if it was previously set
+  const fcmProjectId = get('FCM_PROJECT_ID');
+  if (fcmProjectId) {
+    config.wantAndroid = true;
+    config.fcmProjectId = fcmProjectId;
+    config.fcmClientEmail = get('FCM_CLIENT_EMAIL');
+    const rawFcmKey = get('FCM_PRIVATE_KEY');
+    config.fcmPrivateKey = rawFcmKey ? rawFcmKey.replace(/\\n/g, '\n') : '';
+    config.androidDeviceToken = get('ANDROID_DEVICE_TOKEN');
+  }
+}
+
+async function collectConfig() {
+  const config = {
+    apiKey: '',
+    // iOS APNs
+    wantIos: false,
+    apnsKey: '',
+    apnsKeyId: '',
+    apnsTeamId: '',
+    apnsBundleId: '',
+    apnsProduction: false,
+    deviceToken: '',
+    // Android FCM
+    wantAndroid: false,
+    fcmProjectId: '',
+    fcmClientEmail: '',
+    fcmPrivateKey: '',
+    androidDeviceToken: '',
+  };
+
+  // ── Auto mode: reuse existing key or generate new, skip push config ──
+  if (AUTO_MODE) {
+    step('Auto-configuring...');
+
+    // Preserve existing API_KEY if .env already exists
+    if (fs.existsSync(DOT_ENV_PATH)) {
+      const existing = fs.readFileSync(DOT_ENV_PATH, 'utf-8');
+      const match = existing.match(/^API_KEY=["']?(.+?)["']?$/m);
+      if (match && match[1]) {
+        config.apiKey = match[1];
+        const maskedKey = mask(config.apiKey);
+        console.log(green(`  Existing API key preserved: ${maskedKey}`));
+        loadExistingPushConfig(config);
+        loadExistingAIConfig(config); // Load existing AI config in auto mode
+        if (config.wantIos || config.wantAndroid) {
+          console.log(green('  Existing push config preserved.'));
+        } else {
+          console.log(
+            dim('  Push notifications not configured (add later with "shooter setup --push")')
+          );
+        }
+        if (config.NEUROLINK_PROVIDER) {
+          console.log(green('  Existing AI config preserved.'));
+        } else {
+          console.log(dim('  AI providers not configured (add later with "shooter setup")'));
+        }
+        console.log('');
+        return config;
+      }
+    }
+
+    config.apiKey = generateApiKey(); // Changed to generateApiKey()
+    const maskedKey = mask(config.apiKey);
+    console.log(green(`  API key generated: ${maskedKey}`));
+    console.log(dim('  Push notifications not configured (add later with "shooter setup --push")'));
+    console.log(dim('  AI providers not configured (add later with "shooter setup")'));
+    console.log('');
+    return config;
+  }
+
+  // ── API Key ──────────────────────────────────────────────────────
+  step('Server authentication');
+  const apiKeyAnswer = await ask(`  API_KEY ${dim('(press Enter to auto-generate)')}: `);
+  if (apiKeyAnswer) {
+    config.apiKey = apiKeyAnswer;
+  } else {
+    config.apiKey = generateApiKey(); // Changed to generateApiKey()
+    const maskedKey = mask(config.apiKey);
+    console.log(green(`  Generated API key: ${maskedKey}`));
+    console.log(dim('  (Saved to ~/.shooter/.env)'));
+  }
+  console.log('');
+
+  // ── Push notifications: only if --push flag or user opts in ──────
+  if (PUSH_MODE) {
+    // Direct push config mode — user explicitly asked for it
+    step('Push notification setup');
+    await collectPushConfig(config);
+  } else {
+    // Default: skip push, show how to add later
+    // Preserve any existing push config from a previous setup
+    loadExistingPushConfig(config);
+
+    if (config.wantIos || config.wantAndroid) {
+      console.log(dim('  Existing push notification config preserved.'));
+      console.log(dim('  To reconfigure: shooter setup --push'));
+    } else {
+      console.log(dim('  Push notifications are optional and not required for the server.'));
+      console.log(dim('  Terminals, sessions, and the web UI work without push config.'));
+      console.log(dim(`  Add push later: ${cyan('shooter setup --push')}`));
+    }
+    console.log('');
+  }
+
+  // ── AI Providers ───────────────────────────────────────────────────
+  loadExistingAIConfig(config);
+  await collectAIConfig(config);
 
   return config;
 }
@@ -338,7 +644,7 @@ function buildEnvContent(config) {
     `# ${new Date().toISOString()}`,
     '',
     '# Authentication',
-    `API_KEY="${escapeForDoubleQuotedShell(config.apiKey)}"`,
+    `API_KEY=${config.apiKey}`,
     '',
   ];
 
@@ -398,6 +704,17 @@ function buildEnvContent(config) {
   }
   lines.push('');
 
+  // AI / NeuroLink — preserve existing AI keys across re-runs
+  lines.push('# AI / NeuroLink');
+  for (const key of AI_ENV_KEYS) {
+    if (config[key]) {
+      lines.push(`${key}=${config[key]}`);
+    } else {
+      lines.push(`# ${key}=`);
+    }
+  }
+  lines.push('');
+
   // Server
   lines.push('# Server');
   lines.push('# PORT=54007');
@@ -407,7 +724,7 @@ function buildEnvContent(config) {
 }
 
 async function writeEnv(config) {
-  console.log(bold('5. Writing .env file\n'));
+  step('Writing .env file');
 
   if (fs.existsSync(DOT_ENV_PATH) && !AUTO_MODE) {
     const overwrite = await confirm('  .env already exists. Overwrite it?');
@@ -427,69 +744,17 @@ async function writeEnv(config) {
   }
 
   fs.writeFileSync(DOT_ENV_PATH, content, { mode: 0o600 });
+  // Enforce secure permissions even if file already existed
+  fs.chmodSync(DOT_ENV_PATH, 0o600);
   console.log(green('  .env written successfully.'));
   console.log('');
   return true;
 }
 
-// ── Shell profile export ─────────────────────────────────────────────
-
-function detectShellProfile() {
-  const home = require('os').homedir();
-  const shell = process.env.SHELL || '';
-
-  if (shell.endsWith('/zsh')) {
-    return path.join(home, '.zshrc');
-  }
-  if (shell.endsWith('/bash')) {
-    // macOS uses .bash_profile for login shells; Linux uses .bashrc
-    const bashProfile = path.join(home, '.bash_profile');
-    if (fs.existsSync(bashProfile)) return bashProfile;
-    return path.join(home, '.bashrc');
-  }
-  // Fallback for other shells
-  return path.join(home, '.profile');
-}
-
-async function offerShellExport(apiKey) {
-  console.log(bold('6. Shell environment\n'));
-
-  const profilePath = detectShellProfile();
-  const profileName = path.basename(profilePath);
-
-  // Check if export already exists
-  if (fs.existsSync(profilePath)) {
-    const contents = fs.readFileSync(profilePath, 'utf-8');
-    if (contents.includes('export API_KEY=')) {
-      console.log(green(`  export API_KEY is already in ~/${profileName}`));
-      console.log('');
-      return;
-    }
-  }
-
-  console.log(dim('  The Claude Code hooks need API_KEY in your shell environment.'));
-  const shouldAdd = AUTO_MODE || await confirm(`  Add 'export API_KEY=...' to ~/${profileName}?`);
-
-  if (shouldAdd) {
-    const exportLine = `\nexport API_KEY="${escapeForDoubleQuotedShell(apiKey)}"\n`;
-    fs.appendFileSync(profilePath, exportLine, 'utf-8');
-    console.log(green(`  Added to ~/${profileName}`));
-    console.log(
-      yellow(`  Run ${cyan(`source ~/${profileName}`)} or open a new terminal for hooks to work.`)
-    );
-  } else {
-    console.log(
-      yellow('  Skipped. You will need to set API_KEY manually for hooks to authenticate.')
-    );
-    console.log(dim(`  Add this to your shell profile:  export API_KEY="<your key from .env>"`));
-  }
-  console.log('');
-}
-
 // ── Build ────────────────────────────────────────────────────────────
 
 function runBuild() {
-  console.log(bold('7. Building the project...\n'));
+  step('Building the project...');
   try {
     execSync('pnpm build', { cwd: ROOT, stdio: 'inherit' });
     console.log('');
@@ -505,107 +770,6 @@ function runBuild() {
   }
 }
 
-// ── Health check ─────────────────────────────────────────────────────
-
-function testHealth() {
-  return new Promise((resolve) => {
-    console.log(bold('9. Testing server health...\n'));
-
-    const port = process.env.PORT || 54007;
-    let serverProcess;
-    let resolved = false;
-
-    function finish(ok, msg) {
-      if (resolved) return;
-      resolved = true;
-      if (serverProcess && !serverProcess.killed) {
-        serverProcess.kill('SIGTERM');
-      }
-      if (ok) {
-        console.log(green(`  ${msg}`));
-      } else {
-        console.log(yellow(`  ${msg}`));
-      }
-      console.log('');
-      resolve(ok);
-    }
-
-    // Start the server
-    serverProcess = spawn('node', ['--import', 'tsx', 'server.ts'], {
-      cwd: ROOT,
-      stdio: 'pipe',
-      env: { ...process.env, PORT: port.toString(), SHOOTER_HOME, SHOOTER_PKG_ROOT: ROOT },
-    });
-
-    serverProcess.on('error', (err) => {
-      finish(false, `Could not start server: ${err.message}`);
-    });
-
-    serverProcess.on('exit', (code) => {
-      if (!resolved) {
-        finish(false, `Server exited unexpectedly (code ${code}).`);
-      }
-    });
-
-    // Capture stderr/stdout for "listening" signal; try health after delay
-    let output = '';
-    const collectOutput = (data) => {
-      output += data.toString();
-    };
-    serverProcess.stdout.on('data', collectOutput);
-    serverProcess.stderr.on('data', collectOutput);
-
-    // Give the server up to 15 seconds to start, polling every second
-    let attempts = 0;
-    const maxAttempts = 15;
-
-    const poll = setInterval(() => {
-      attempts++;
-      if (resolved) {
-        clearInterval(poll);
-        return;
-      }
-      if (attempts > maxAttempts) {
-        clearInterval(poll);
-        finish(
-          false,
-          'Server did not respond within 15 seconds. You can test manually with: curl http://localhost:' +
-            port +
-            '/api/health'
-        );
-        return;
-      }
-
-      const req = http.get(`http://localhost:${port}/api/health`, (res) => {
-        let body = '';
-        res.on('data', (chunk) => {
-          body += chunk;
-        });
-        res.on('end', () => {
-          clearInterval(poll);
-          try {
-            const data = JSON.parse(body);
-            if (data.status === 'healthy') {
-              finish(true, `Health check passed: status=${data.status}`);
-            } else {
-              finish(
-                true,
-                `Server running (status=${data.status}). Some optional features may need configuration.`
-              );
-            }
-          } catch {
-            finish(true, 'Server responded but health response was not JSON.');
-          }
-        });
-      });
-      req.on('error', () => {
-        // Server not ready yet — will retry
-      });
-      req.setTimeout(2000, () => req.destroy());
-    }, 1000);
-  });
-}
-
 // ── Main ─────────────────────────────────────────────────────────────
 
 async function main() {
@@ -625,17 +789,30 @@ async function main() {
     rl.close();
   });
 
+  // Reset step counter; push mode adds one extra step, AI step adds another
+  _stepNum = 0;
+  _totalSteps = AUTO_MODE ? 5 : PUSH_MODE ? 7 : 6;
+
   printBanner();
+
+  if (PUSH_MODE) {
+    console.log(bold('  Adding push notification support...\n'));
+  }
+
   checkPrerequisites();
 
   const config = await collectConfig();
   await writeEnv(config);
-  await offerShellExport(config.apiKey);
+
+  // API_KEY is stored in ~/.shooter/.env — hooks read it automatically
+  console.log(dim('  API_KEY is stored in ~/.shooter/.env'));
+  console.log(dim('  Claude Code hooks read it automatically from there.'));
+  console.log('');
 
   const buildOk = runBuild();
 
   // ── Remote access info ───────────────────────────────────────────────
-  console.log(bold('8. Remote access (optional)\n'));
+  step('Remote access (optional)');
 
   let cloudflaredAvailable = false;
   try {
@@ -648,14 +825,19 @@ async function main() {
   if (!cloudflaredAvailable) {
     console.log(yellow('  cloudflared not found.'));
     console.log(dim('  Install it to get a public URL for your phone:'));
-    console.log(dim('  https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/'));
+    console.log(
+      dim(
+        '  https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/'
+      )
+    );
     console.log('');
     console.log(dim('  Once installed, run:'));
     console.log(cyan('    cloudflared tunnel --url http://localhost:54007'));
     console.log('');
   } else {
     const port = process.env.PORT || 54007;
-    const startTunnel = AUTO_MODE || await confirm('  Start a Cloudflare Tunnel now to get your public URL?');
+    const startTunnel =
+      AUTO_MODE || (await confirm('  Start a Cloudflare Tunnel now to get your public URL?'));
     if (startTunnel) {
       console.log(dim('\n  Starting tunnel... (this may take a few seconds)\n'));
       await new Promise((resolve) => {
@@ -672,7 +854,11 @@ async function main() {
             console.log(green('  Tunnel URL (use this on your phone):'));
             console.log(`\n  ${C.bold}${C.cyan}${match[0]}${C.reset}\n`);
             console.log(dim('  Keep this terminal session open to maintain the tunnel.'));
-            console.log(dim('  For a persistent tunnel, see: https://developers.cloudflare.com/cloudflare-one/'));
+            console.log(
+              dim(
+                '  For a persistent tunnel, see: https://developers.cloudflare.com/cloudflare-one/'
+              )
+            );
             console.log('');
             resolve();
           }
@@ -710,7 +896,8 @@ async function main() {
   rl.close();
 
   if (buildOk) {
-    await testHealth();
+    console.log(green('  Ready to start! Run: shooter start'));
+    console.log('');
   }
 
   // ── Done ───────────────────────────────────────────────────────────
@@ -726,8 +913,17 @@ async function main() {
   console.log(bold('  Your API key (enter this in the app on your phone):'));
   console.log(`\n  ${C.bold}${C.cyan}${mask(config.apiKey)}${C.reset}\n`);
   if (!config.wantIos && !config.wantAndroid) {
-    console.log(yellow('  Note: No push notification platform was configured.'));
-    console.log(dim('  Run shooter setup again to add iOS or Android push notifications.'));
+    console.log(bold('  Optional add-ons:'));
+    console.log(`  ${dim('Push notifications:')}  ${cyan('shooter setup --push')}`);
+    console.log(
+      `  ${dim('Cloudflare Tunnel:')}   ${cyan('shooter start')} ${dim('(auto-starts tunnel)')}`
+    );
+    console.log('');
+  } else {
+    const platforms = [];
+    if (config.wantIos) platforms.push('iOS');
+    if (config.wantAndroid) platforms.push('Android');
+    console.log(green(`  Push notifications: ${platforms.join(' + ')} configured`));
     console.log('');
   }