ai-lens 0.4.0 → 0.6.0

package/.commithash

@@ -1 +1 @@
-b46a47e
+358f236

package/bin/ai-lens.js

@@ -30,28 +30,12 @@ switch (command) {
     console.log(`ai-lens v${version} (${commit})`);
     break;
   }
-  case 'admin': {
-    const sub = process.argv[3];
-    const { createInvite, listInvites } = await import('../cli/admin.js');
-    if (sub === 'create-invite') await createInvite();
-    else if (sub === 'list-invites') await listInvites();
-    else {
-      console.log('Usage: ai-lens admin <command>');
-      console.log('');
-      console.log('Commands:');
-      console.log('  create-invite  Create a team invite token');
-      console.log('  list-invites   List invite tokens');
-      process.exit(1);
-    }
-    break;
-  }
   default:
     console.log('Usage: ai-lens <command>');
     console.log('');
     console.log('Commands:');
     console.log('  init            Configure AI tool hooks for event capture');
     console.log('  remove          Remove AI Lens hooks and client files');
-    console.log('  admin           Admin commands (create-invite, list-invites)');
     console.log('  mcp             Start the MCP server (stdio transport)');
     console.log('  version         Show package version and commit hash');
     process.exit(command ? 1 : 0);

package/cli/hooks.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, copyFileSync, renameSync, mkdirSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, renameSync, mkdirSync, rmSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -150,6 +150,8 @@ export const TOOL_CONFIGS = [
     hookDefs: CLAUDE_CODE_HOOKS,
     topLevelFields: {},
     sharedConfig: true,
+    // Older init versions wrote hooks here — clean up on init/remove
+    legacyConfigPaths: [join(homedir(), '.claude', 'hooks.json')],
   },
   {
     name: 'Cursor',
@@ -350,6 +352,123 @@ export function writeHooksConfig(tool, config) {
 // Describe what will happen (for plan display)
 // ---------------------------------------------------------------------------
 
+/**
+ * Clean up AI Lens hooks from legacy config paths (e.g. ~/.claude/hooks.json).
+ * Returns array of { path, action } describing what was done.
+ */
+export function cleanupLegacyHooks(tool) {
+  const results = [];
+  if (!Array.isArray(tool.legacyConfigPaths)) return results;
+
+  for (const legacyPath of tool.legacyConfigPaths) {
+    if (legacyPath === tool.configPath) continue;
+    if (!existsSync(legacyPath)) continue;
+
+    let raw;
+    try {
+      raw = readFileSync(legacyPath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    let config;
+    try {
+      config = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+
+    // Check if any AI Lens hooks exist in this file
+    const hooks = config.hooks;
+    if (!hooks || typeof hooks !== 'object') continue;
+
+    let hasAiLens = false;
+    for (const entries of Object.values(hooks)) {
+      if (Array.isArray(entries) && entries.some(e => isAiLensHook(e))) {
+        hasAiLens = true;
+        break;
+      }
+    }
+    if (!hasAiLens) continue;
+
+    // Strip AI Lens hooks
+    const stripped = buildStrippedConfig(tool, config);
+    if (stripped) {
+      writeFileSync(legacyPath, JSON.stringify(stripped, null, 2) + '\n');
+      results.push({ path: legacyPath, action: 'cleaned' });
+    } else {
+      unlinkSync(legacyPath);
+      results.push({ path: legacyPath, action: 'deleted' });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Delete .mcp.json in cwd if it was left with empty mcpServers by `claude mcp remove`.
+ */
+export function cleanupEmptyMcpJson() {
+  const mcpJsonPath = join(process.cwd(), '.mcp.json');
+  try {
+    const content = JSON.parse(readFileSync(mcpJsonPath, 'utf-8'));
+    if (content.mcpServers
+        && Object.keys(content.mcpServers).length === 0
+        && Object.keys(content).length === 1) {
+      unlinkSync(mcpJsonPath);
+    }
+  } catch {
+    // file doesn't exist or isn't valid JSON — nothing to clean
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Cursor MCP helpers (no CLI — direct JSON editing)
+// ---------------------------------------------------------------------------
+
+const CURSOR_MCP_GLOBAL = join(homedir(), '.cursor', 'mcp.json');
+
+function cursorMcpEntry(mcpUrl) {
+  return { url: mcpUrl };
+}
+
+function readJsonSafe(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Add or update ai-lens MCP server in Cursor's mcp.json.
+ */
+export function addCursorMcp(mcpUrl) {
+  const config = readJsonSafe(CURSOR_MCP_GLOBAL) || { mcpServers: {} };
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers['ai-lens'] = cursorMcpEntry(mcpUrl);
+  mkdirSync(dirname(CURSOR_MCP_GLOBAL), { recursive: true });
+  writeFileSync(CURSOR_MCP_GLOBAL, JSON.stringify(config, null, 2) + '\n');
+}
+
+/**
+ * Remove ai-lens MCP server from Cursor's mcp.json.
+ * Also checks .cursor/mcp.json in cwd (project scope).
+ */
+export function removeCursorMcp() {
+  const paths = [CURSOR_MCP_GLOBAL, join(process.cwd(), '.cursor', 'mcp.json')];
+  for (const p of paths) {
+    const config = readJsonSafe(p);
+    if (!config?.mcpServers?.['ai-lens']) continue;
+    delete config.mcpServers['ai-lens'];
+    if (Object.keys(config.mcpServers).length === 0 && Object.keys(config).length === 1) {
+      unlinkSync(p);
+    } else {
+      writeFileSync(p, JSON.stringify(config, null, 2) + '\n');
+    }
+  }
+}
+
 export function describePlan(tool, analysis) {
   const hookNames = Object.keys(tool.hookDefs);
 

package/cli/init.js

@@ -13,6 +13,7 @@ import {
   CAPTURE_PATH, detectInstalledTools,
   analyzeToolHooks, buildMergedConfig, writeHooksConfig, describePlan,
   installClientFiles, readLensConfig, saveLensConfig, getVersionInfo,
+  cleanupLegacyHooks, cleanupEmptyMcpJson, addCursorMcp, removeCursorMcp,
 } from './hooks.js';
 
 function ask(question) {
@@ -25,8 +26,40 @@ function ask(question) {
   });
 }
 
-// Default transport credentials (same as client/config.js DEFAULT_AUTH_TOKEN)
-const TRANSPORT_AUTH = 'collector:secret-collector-token-2026-ai-lens';
+function getJson(url) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === 'https:';
+    const requestFn = isHttps ? httpsRequest : httpRequest;
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (isHttps ? 443 : 80),
+      path: parsed.pathname + (parsed.search || ''),
+      method: 'GET',
+      headers: { 'Accept': 'application/json' },
+      timeout: 15_000,
+    };
+    const req = requestFn(options, (res) => {
+      let buf = '';
+      res.on('data', (chunk) => { buf += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(buf);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json);
+          } else {
+            reject(new Error(json.error || `Server responded ${res.statusCode}`));
+          }
+        } catch {
+          reject(new Error(`Server responded ${res.statusCode}: ${buf}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+    req.end();
+  });
+}
 
 function postJson(url, body) {
   return new Promise((resolve, reject) => {
@@ -42,7 +75,6 @@ function postJson(url, body) {
       headers: {
         'Content-Type': 'application/json',
         'Content-Length': Buffer.byteLength(data),
-        'Authorization': 'Basic ' + Buffer.from(TRANSPORT_AUTH).toString('base64'),
       },
       timeout: 15_000,
     };
@@ -69,6 +101,131 @@ function postJson(url, body) {
   });
 }
 
+function postForm(url, params) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === 'https:';
+    const requestFn = isHttps ? httpsRequest : httpRequest;
+    const data = new URLSearchParams(params).toString();
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (isHttps ? 443 : 80),
+      path: parsed.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': Buffer.byteLength(data),
+      },
+      timeout: 15_000,
+    };
+    const req = requestFn(options, (res) => {
+      let buf = '';
+      res.on('data', (chunk) => { buf += chunk; });
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(buf) });
+        } catch {
+          reject(new Error(`Server responded ${res.statusCode}: ${buf}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+    req.write(data);
+    req.end();
+  });
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function deviceCodeAuth(serverUrl) {
+  // 1. Fetch Auth0 config from server
+  let config;
+  try {
+    config = await getJson(`${serverUrl}/api/auth/config`);
+  } catch (err) {
+    throw new Error(`Could not fetch auth config from server: ${err.message}`);
+  }
+
+  if (!config.enabled || !config.domain || !config.cliClientId) {
+    throw new Error('Auth0 device code flow not configured on server (missing AUTH0_CLI_CLIENT_ID)');
+  }
+
+  const { domain, cliClientId } = config;
+
+  // 2. Request device code
+  const codeParams = {
+    client_id: cliClientId,
+    scope: 'openid profile email',
+  };
+
+  const codeResp = await postForm(`https://${domain}/oauth/device/code`, codeParams);
+  if (codeResp.status !== 200) {
+    throw new Error(`Device code request failed: ${JSON.stringify(codeResp.data)}`);
+  }
+
+  const {
+    device_code,
+    user_code,
+    verification_uri_complete,
+    verification_uri,
+    interval: pollInterval = 5,
+    expires_in,
+  } = codeResp.data;
+
+  // 3. Show URL + code
+  blank();
+  info('  Open this URL in your browser to authenticate:');
+  blank();
+  info(`    ${verification_uri_complete || verification_uri}`);
+  blank();
+  if (user_code) {
+    info(`  Code: ${user_code}`);
+    blank();
+  }
+  info(`  Waiting for browser login (expires in ${Math.floor(expires_in / 60)} min)...`);
+
+  // 4. Poll for token
+  let interval = pollInterval;
+  const deadline = Date.now() + expires_in * 1000;
+
+  while (Date.now() < deadline) {
+    await sleep(interval * 1000);
+
+    const tokenResp = await postForm(`https://${domain}/oauth/token`, {
+      grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      client_id: cliClientId,
+      device_code,
+    });
+
+    if (tokenResp.status === 200 && tokenResp.data.id_token) {
+      // 5. Exchange JWT for personal token
+      const result = await postJson(`${serverUrl}/api/auth/device-token`, {
+        jwt: tokenResp.data.id_token,
+      });
+      return result;
+    }
+
+    const err = tokenResp.data.error;
+    if (err === 'authorization_pending') {
+      continue;
+    } else if (err === 'slow_down') {
+      interval += 5;
+      continue;
+    } else if (err === 'expired_token') {
+      throw new Error('Device code expired. Please try again.');
+    } else if (err === 'access_denied') {
+      throw new Error('Authentication was denied.');
+    } else {
+      throw new Error(`Unexpected token response: ${JSON.stringify(tokenResp.data)}`);
+    }
+  }
+
+  throw new Error('Device code expired. Please try again.');
+}
+
 export default async function init() {
   const { version, commit } = getVersionInfo();
   initLogger(`v${version} (${commit})`);
@@ -103,7 +260,7 @@ export default async function init() {
   const serverInput = await ask(
     `Server URL (Enter = ${currentServer}): `,
   );
-  const serverUrl = serverInput || currentServer;
+  const serverUrl = (serverInput || currentServer).replace(/\/+$/, '');
   info(`  Server: ${serverUrl}`);
 
   // Project filter
@@ -126,41 +283,17 @@ export default async function init() {
   }
   blank();
 
-  // Authentication (required)
+  // Authentication
   heading('Authentication');
   if (!currentConfig.authToken) {
-    info('Invite token is required. Get one from your team lead.');
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const inviteInput = await ask('Invite token: ');
-      if (!inviteInput) {
-        warn('  Invite token is required to continue.');
-        continue;
-      }
-      if (!inviteInput.startsWith('ailens_inv_')) {
-        warn('  Token must start with ailens_inv_. Try again.');
-        continue;
-      }
-      try {
-        let email, gitName;
-        try {
-          email = execSync('git config user.email', { encoding: 'utf-8' }).trim();
-          gitName = execSync('git config user.name', { encoding: 'utf-8' }).trim();
-        } catch {
-          error('  Could not read git identity. Set git config user.email and user.name first.');
-          return;
-        }
-        const result = await postJson(serverUrl + '/api/auth/accept-invite', {
-          token: inviteInput, email, name: gitName,
-        });
-        newConfig.authToken = result.token;
-        saveLensConfig(newConfig);
-        success(`  Authenticated! Team: ${result.team_id}`);
-        break;
-      } catch (err) {
-        error(`  Authentication failed: ${err.message}`);
-        info('  Try again.');
-      }
+    try {
+      const result = await deviceCodeAuth(serverUrl);
+      newConfig.authToken = result.token;
+      saveLensConfig(newConfig);
+      success(`  Authenticated as ${result.name} (${result.email})`);
+    } catch (err) {
+      error(`  Authentication failed: ${err.message}`);
+      return;
     }
   } else {
     success('  Already authenticated (token present)');
@@ -196,6 +329,13 @@ export default async function init() {
   // Filter to tools that need changes
   const pending = analyses.filter(a => a.analysis.status !== 'current');
 
+  // Clean up legacy hook locations (always, even if current hooks are up-to-date)
+  for (const { tool } of analyses) {
+    for (const lr of cleanupLegacyHooks(tool)) {
+      success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
+    }
+  }
+
   if (pending.length === 0) {
     success('Everything is up-to-date. Nothing to do.');
   } else {
@@ -258,35 +398,56 @@ export default async function init() {
     blank();
   }
 
-  // MCP setup (only if Claude Code is installed)
+  // MCP setup (HTTP transport — auth via OAuth in browser, no token needed)
+  const mcpUrl = `${serverUrl}/mcp`;
+
+  // Claude Code MCP
   const claudeDir = join(homedir(), '.claude');
   const hasClaudeDir = existsSync(claudeDir);
   let hasClaudeCli = false;
-  try {
-    execSync('which claude', { stdio: 'ignore' });
-    hasClaudeCli = true;
-  } catch {}
+  try { execSync('which claude', { stdio: 'ignore' }); hasClaudeCli = true; } catch {}
 
   if (hasClaudeDir && hasClaudeCli) {
-    heading('MCP Server');
+    heading('MCP Server — Claude Code');
     const mcpAnswer = await ask('Set up AI Lens MCP server in Claude Code? [Y/n] ');
     if (!mcpAnswer || mcpAnswer.toLowerCase() === 'y') {
-      const mcpToken = newConfig.authToken;
-      if (!mcpToken) {
-        warn('  No auth token available — authenticate first.');
-      } else {
-        try {
-          execSync(
-            `claude mcp add ai-lens -e AI_LENS_SERVER_URL=${serverUrl} -e AI_LENS_AUTH_TOKEN=${mcpToken} -- npx -y ai-lens mcp`,
-            { stdio: 'inherit' },
-          );
-          success('  MCP server registered in Claude Code');
-        } catch (err) {
-          error(`  Failed to register MCP server: ${err.message}`);
-        }
+      const scopeInput = await ask('  Scope — user, local, or project? (Enter = user): ');
+      const scope = ['local', 'project', 'user'].includes(scopeInput) ? scopeInput : 'user';
+      try {
+        // Remove old stdio-based MCP from all scopes, then add HTTP-based
+        try { execSync('claude mcp remove ai-lens -s local', { stdio: 'ignore' }); } catch {}
+        try { execSync('claude mcp remove ai-lens -s project', { stdio: 'ignore' }); } catch {}
+        try { execSync('claude mcp remove ai-lens -s user', { stdio: 'ignore' }); } catch {}
+        cleanupEmptyMcpJson();
+        execSync(
+          `claude mcp add --transport http ai-lens -s ${scope} ${mcpUrl}`,
+          { stdio: 'inherit' },
+        );
+        success(`  MCP server registered in Claude Code (${scope})`);
+      } catch (err) {
+        error(`  Failed to register MCP server: ${err.message}`);
+      }
+    } else {
+      info('  Skipped');
+    }
+    blank();
+  }
+
+  // Cursor MCP
+  const cursorDir = join(homedir(), '.cursor');
+  if (existsSync(cursorDir)) {
+    heading('MCP Server — Cursor');
+    const cursorMcpAnswer = await ask('Set up AI Lens MCP server in Cursor? [Y/n] ');
+    if (!cursorMcpAnswer || cursorMcpAnswer.toLowerCase() === 'y') {
+      try {
+        removeCursorMcp();
+        addCursorMcp(mcpUrl);
+        success('  MCP server registered in Cursor (~/.cursor/mcp.json)');
+      } catch (err) {
+        error(`  Failed to register MCP server: ${err.message}`);
       }
     } else {
-      info('  Skipped MCP setup');
+      info('  Skipped');
     }
     blank();
   }

package/cli/remove.js

@@ -1,5 +1,8 @@
 import { createInterface } from 'node:readline';
-import { unlinkSync } from 'node:fs';
+import { unlinkSync, existsSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 import {
   initLogger, info, success, warn, error,
   heading, detail, blank, getLogPath,
@@ -7,6 +10,7 @@ import {
 import {
   detectInstalledTools, analyzeToolHooks,
   buildStrippedConfig, writeHooksConfig, removeClientFiles, getVersionInfo,
+  cleanupLegacyHooks, cleanupEmptyMcpJson, removeCursorMcp,
 } from './hooks.js';
 
 function ask(question) {
@@ -88,6 +92,46 @@ export default async function remove() {
   }
   blank();
 
+  // Clean up legacy hook locations
+  for (const tool of tools) {
+    for (const lr of cleanupLegacyHooks(tool)) {
+      success(`  ${tool.name}: ${lr.action} legacy hooks in ${lr.path}`);
+    }
+  }
+  blank();
+
+  // Remove MCP servers
+  heading('Removing MCP servers...');
+
+  // Claude Code
+  const claudeDir = join(homedir(), '.claude');
+  let hasClaudeCli = false;
+  try { execSync('which claude', { stdio: 'ignore' }); hasClaudeCli = true; } catch {}
+
+  if (existsSync(claudeDir) && hasClaudeCli) {
+    try {
+      try { execSync('claude mcp remove ai-lens -s local', { stdio: 'ignore' }); } catch {}
+      try { execSync('claude mcp remove ai-lens -s project', { stdio: 'ignore' }); } catch {}
+      try { execSync('claude mcp remove ai-lens -s user', { stdio: 'ignore' }); } catch {}
+      cleanupEmptyMcpJson();
+      success('  Claude Code: MCP server removed');
+    } catch (err) {
+      error(`  Claude Code: failed — ${err.message}`);
+    }
+  }
+
+  // Cursor
+  const cursorDir = join(homedir(), '.cursor');
+  if (existsSync(cursorDir)) {
+    try {
+      removeCursorMcp();
+      success('  Cursor: MCP server removed');
+    } catch (err) {
+      error(`  Cursor: failed — ${err.message}`);
+    }
+  }
+  blank();
+
   // Remove client files
   heading('Removing client files...');
   try {

package/mcp-server/index.js

@@ -181,6 +181,27 @@ server.tool(
   }
 );
 
+// 10. search
+server.tool(
+  "search",
+  "Search across all sessions, tasks, and projects using natural language. Returns matching chains grouped by relevance with snippets. Use chain_id from results with get_chain or get_chain_analysis for full details.",
+  {
+    query: z.string().describe("Search query (e.g., 'auth0 device flow', 'migration bug', 'token storage')"),
+    days: z.number().optional().describe("Time window in days (default: 90)"),
+    developer_id: z.string().optional().describe("Filter to specific developer (UUID)"),
+    project: z.string().optional().describe("Filter by project path substring"),
+    limit: z.number().optional().describe("Max results (default: 20, max: 50)"),
+  },
+  async ({ query, days, developer_id, project, limit }) => {
+    const params = new URLSearchParams({ q: query });
+    if (days) params.set('days', String(days));
+    if (developer_id) params.set('developer_id', developer_id);
+    if (project) params.set('project', project);
+    if (limit) params.set('limit', String(limit));
+    return textResult(await apiCall(`/api/dashboard/search?${params}`));
+  }
+);
+
 const transport = new StdioServerTransport();
 await server.connect(transport);
 console.error("AI Lens MCP server running");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {

package/cli/admin.js

@@ -1,120 +0,0 @@
-import { createInterface } from 'node:readline';
-import { request as httpRequest } from 'node:http';
-import { request as httpsRequest } from 'node:https';
-import { readLensConfig } from './hooks.js';
-
-function ask(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise(resolve => {
-    rl.question(question, answer => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-function adminRequest(method, url, body) {
-  const secret = process.env.AI_LENS_ADMIN_SECRET;
-  if (!secret) {
-    throw new Error('AI_LENS_ADMIN_SECRET env var is required');
-  }
-  return new Promise((resolve, reject) => {
-    const parsed = new URL(url);
-    const isHttps = parsed.protocol === 'https:';
-    const requestFn = isHttps ? httpsRequest : httpRequest;
-    const data = body ? JSON.stringify(body) : null;
-    const options = {
-      hostname: parsed.hostname,
-      port: parsed.port || (isHttps ? 443 : 80),
-      path: parsed.pathname + (parsed.search || ''),
-      method,
-      headers: {
-        'X-Admin-Secret': secret,
-        ...(data ? {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(data),
-        } : {}),
-      },
-      timeout: 15_000,
-    };
-    const req = requestFn(options, (res) => {
-      let buf = '';
-      res.on('data', (chunk) => { buf += chunk; });
-      res.on('end', () => {
-        try {
-          const json = JSON.parse(buf);
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            resolve(json);
-          } else {
-            reject(new Error(json.error || `Server responded ${res.statusCode}`));
-          }
-        } catch {
-          reject(new Error(`Server responded ${res.statusCode}: ${buf}`));
-        }
-      });
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
-    if (data) req.write(data);
-    req.end();
-  });
-}
-
-function getServerUrl() {
-  const config = readLensConfig();
-  return config.serverUrl || process.env.AI_LENS_SERVER_URL || 'http://localhost:3000';
-}
-
-export async function createInvite() {
-  const serverUrl = getServerUrl();
-  const teamId = await ask('Team ID: ');
-  if (!teamId) {
-    console.error('Team ID is required');
-    process.exit(1);
-  }
-  const label = await ask('Label (optional): ');
-  const maxUsesStr = await ask('Max uses (optional, Enter = unlimited): ');
-  const maxUses = maxUsesStr ? parseInt(maxUsesStr, 10) : undefined;
-
-  try {
-    const result = await adminRequest('POST', `${serverUrl}/api/auth/admin/invite-tokens`, {
-      team_id: teamId,
-      label: label || undefined,
-      max_uses: maxUses,
-    });
-    console.log('\nInvite token created:');
-    console.log(`  Token:    ${result.token}`);
-    console.log(`  Team:     ${result.team_id}`);
-    if (result.label) console.log(`  Label:    ${result.label}`);
-    if (result.max_uses) console.log(`  Max uses: ${result.max_uses}`);
-    console.log('\nShare this token with developers. They can use it during: npx ai-lens init');
-  } catch (err) {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-export async function listInvites() {
-  const serverUrl = getServerUrl();
-  const teamId = await ask('Team ID (optional, Enter = all): ');
-  const query = teamId ? `?team_id=${encodeURIComponent(teamId)}` : '';
-
-  try {
-    const tokens = await adminRequest('GET', `${serverUrl}/api/auth/admin/invite-tokens${query}`);
-    if (tokens.length === 0) {
-      console.log('No invite tokens found.');
-      return;
-    }
-    console.log(`\n${'ID'.padEnd(38)}${'Team'.padEnd(20)}${'Label'.padEnd(25)}${'Uses'.padEnd(10)}${'Created'}`);
-    console.log('-'.repeat(110));
-    for (const t of tokens) {
-      const uses = t.max_uses ? `${t.uses}/${t.max_uses}` : `${t.uses}`;
-      console.log(
-        `${t.id.padEnd(38)}${(t.team_id || '').padEnd(20)}${(t.label || '').padEnd(25)}${uses.padEnd(10)}${t.created_at}`,
-      );
-    }
-  } catch (err) {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-  }
-}