figmanage 0.1.0

package/dist/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { createServer } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { loadAuthConfig, hasPat, hasCookie } from './auth/client.js';
+import { registerTools } from './tools/register.js';
+// Import tool modules (side-effect: registers via defineTool)
+import './tools/navigate.js';
+import './tools/files.js';
+import './tools/projects.js';
+import './tools/permissions.js';
+import './tools/comments.js';
+import './tools/export.js';
+import './tools/versions.js';
+import './tools/branching.js';
+import './tools/components.js';
+import './tools/webhooks.js';
+import './tools/reading.js';
+import './tools/analytics.js';
+import './tools/variables.js';
+import './tools/org.js';
+import './tools/libraries.js';
+import './tools/teams.js';
+import './tools/compound.js';
+const ALL_TOOLSETS = [
+    'navigate', 'files', 'projects', 'permissions', 'org',
+    'versions', 'branching', 'comments', 'export',
+    'analytics', 'reading', 'components', 'webhooks', 'variables',
+    'compound', 'teams', 'libraries',
+];
+const TOOLSET_PRESETS = {
+    starter: ['navigate', 'reading', 'comments', 'export'],
+    admin: ['navigate', 'org', 'permissions', 'analytics', 'teams', 'libraries'],
+    readonly: ['navigate', 'reading', 'comments', 'export', 'components', 'versions'],
+    full: ALL_TOOLSETS,
+};
+function parseToolsets(env) {
+    if (!env)
+        return new Set(ALL_TOOLSETS);
+    if (env in TOOLSET_PRESETS)
+        return new Set(TOOLSET_PRESETS[env]);
+    const requested = env.split(',').map(s => s.trim());
+    const valid = requested.filter(t => ALL_TOOLSETS.includes(t));
+    return new Set(valid.length > 0 ? valid : ALL_TOOLSETS);
+}
+function parseHttpPort(argv) {
+    const idx = argv.indexOf('--http');
+    if (idx === -1)
+        return undefined;
+    const port = Number(argv[idx + 1]);
+    if (!port || port < 1 || port > 65535) {
+        console.error('--http requires a valid port number (1-65535)');
+        process.exit(1);
+    }
+    return port;
+}
+async function main() {
+    const config = loadAuthConfig();
+    const readOnly = process.env.FIGMA_READ_ONLY === '1' || process.env.FIGMA_READ_ONLY === 'true';
+    const enabledToolsets = parseToolsets(process.env.FIGMA_TOOLSETS);
+    if (!hasPat(config) && !hasCookie(config)) {
+        console.error('No auth configured. Set FIGMA_PAT for public API access, or ' +
+            'FIGMA_AUTH_COOKIE + FIGMA_USER_ID for internal API access.');
+        process.exit(1);
+    }
+    const server = new McpServer({
+        name: 'figmanage',
+        version: '0.1.0',
+    });
+    registerTools(server, config, enabledToolsets, readOnly);
+    const httpPort = parseHttpPort(process.argv);
+    if (httpPort) {
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+        });
+        const httpServer = createServer(async (req, res) => {
+            const url = new URL(req.url ?? '/', `http://localhost:${httpPort}`);
+            if (url.pathname === '/mcp') {
+                await transport.handleRequest(req, res);
+            }
+            else {
+                res.writeHead(404).end('Not found');
+            }
+        });
+        await server.connect(transport);
+        httpServer.listen(httpPort, () => {
+            console.error(`figmanage HTTP server listening on http://localhost:${httpPort}/mcp`);
+        });
+    }
+    else {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    }
+}
+main().catch((err) => {
+    console.error('Fatal:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/setup.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=setup.d.ts.map

package/dist/setup.js

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+import { execSync, execFileSync } from 'child_process';
+import { createDecipheriv, pbkdf2Sync } from 'crypto';
+import { copyFileSync, unlinkSync, mkdtempSync, existsSync, rmdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir, homedir, platform } from 'os';
+import axios from 'axios';
+const COOKIE_NAME = '__Host-figma.authn';
+// --- Platform-specific Chrome paths ---
+function getChromePaths() {
+    switch (platform()) {
+        case 'darwin':
+            return [join(homedir(), 'Library/Application Support/Google/Chrome')];
+        case 'linux':
+            return [
+                join(homedir(), '.config/google-chrome'),
+                join(homedir(), '.config/chromium'),
+            ];
+        case 'win32': {
+            const localAppData = process.env.LOCALAPPDATA || join(homedir(), 'AppData/Local');
+            return [join(localAppData, 'Google/Chrome/User Data')];
+        }
+        default:
+            return [];
+    }
+}
+// --- Chrome profile discovery ---
+function findChromeProfiles() {
+    const chromePaths = getChromePaths();
+    const profiles = [];
+    for (const base of chromePaths) {
+        if (!existsSync(base))
+            continue;
+        const defaultProfile = join(base, 'Default');
+        if (existsSync(join(defaultProfile, 'Cookies')))
+            profiles.push(defaultProfile);
+        for (let i = 1; i <= 20; i++) {
+            const profile = join(base, `Profile ${i}`);
+            if (existsSync(join(profile, 'Cookies')))
+                profiles.push(profile);
+        }
+    }
+    if (profiles.length === 0)
+        throw new Error('No Chrome profiles with Cookies found.');
+    return profiles;
+}
+// --- macOS cookie decryption ---
+function getMacDecryptionKey() {
+    const password = execFileSync('security', ['find-generic-password', '-w', '-s', 'Chrome Safe Storage'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    return pbkdf2Sync(password, 'saltysalt', 1003, 16, 'sha1');
+}
+// --- Linux cookie decryption ---
+function getLinuxDecryptionKey() {
+    // Try GNOME Keyring first via secret-tool
+    try {
+        const password = execSync('secret-tool lookup application chrome', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        if (password)
+            return pbkdf2Sync(password, 'saltysalt', 1, 16, 'sha1');
+    }
+    catch {
+        // secret-tool not available or no entry
+    }
+    // Fall back to default Chrome password
+    return pbkdf2Sync('peanuts', 'saltysalt', 1, 16, 'sha1');
+}
+// --- Windows cookie decryption ---
+function getWindowsDecryptionKey(chromeBase) {
+    const localStatePath = join(chromeBase, 'Local State');
+    if (!existsSync(localStatePath)) {
+        throw new Error('Chrome Local State file not found. Cannot decrypt cookies on Windows.');
+    }
+    const localState = JSON.parse(readFileSync(localStatePath, 'utf-8'));
+    const encryptedKeyB64 = localState?.os_crypt?.encrypted_key;
+    if (!encryptedKeyB64) {
+        throw new Error('No encrypted_key in Chrome Local State.');
+    }
+    // The key is base64-encoded, with a 'DPAPI' prefix (5 bytes) before the actual DPAPI blob
+    const encryptedKey = Buffer.from(encryptedKeyB64, 'base64');
+    if (encryptedKey.toString('utf-8', 0, 5) !== 'DPAPI') {
+        throw new Error('Unexpected encrypted_key format (missing DPAPI prefix).');
+    }
+    const dpapiBlob = encryptedKey.slice(5).toString('base64');
+    // Use PowerShell to call DPAPI Unprotect
+    const psScript = `
+    Add-Type -AssemblyName System.Security
+    $blob = [Convert]::FromBase64String('${dpapiBlob}')
+    $dec = [Security.Cryptography.ProtectedData]::Unprotect($blob, $null, [Security.Cryptography.DataProtectionScope]::CurrentUser)
+    [Convert]::ToBase64String($dec)
+  `.trim().replace(/\n/g, '; ');
+    const decryptedB64 = execSync(`powershell -NoProfile -NonInteractive -Command "${psScript}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    return Buffer.from(decryptedB64, 'base64');
+}
+// --- Decryption ---
+function decryptCBC(encrypted, key) {
+    // v10 prefix = Chrome AES-128-CBC encryption (macOS and Linux)
+    if (encrypted.length > 3 && encrypted[0] === 0x76 && encrypted[1] === 0x31 && encrypted[2] === 0x30) {
+        const iv = Buffer.alloc(16, 0x20); // Chrome uses space (0x20) as IV
+        const decipher = createDecipheriv('aes-128-cbc', key, iv);
+        const decrypted = Buffer.concat([decipher.update(encrypted.slice(3)), decipher.final()]);
+        // Chrome may prepend binary metadata before the cookie value.
+        // The actual cookie is URL-encoded JSON starting with %7B or raw JSON starting with {
+        const str = decrypted.toString('binary');
+        const jsonStart = str.indexOf('%7B');
+        if (jsonStart >= 0)
+            return str.slice(jsonStart);
+        const rawJsonStart = str.indexOf('{');
+        if (rawJsonStart >= 0)
+            return str.slice(rawJsonStart);
+        throw new Error('Decrypted cookie data does not contain expected JSON value');
+    }
+    return encrypted.toString('utf-8');
+}
+function decryptWindows(encrypted, key) {
+    // Windows Chrome uses AES-256-GCM with v10 prefix
+    // Format: v10 (3 bytes) + nonce (12 bytes) + ciphertext + tag (16 bytes)
+    if (encrypted.length > 3 && encrypted[0] === 0x76 && encrypted[1] === 0x31 && encrypted[2] === 0x30) {
+        const nonce = encrypted.slice(3, 15);
+        const ciphertextWithTag = encrypted.slice(15);
+        const tag = ciphertextWithTag.slice(ciphertextWithTag.length - 16);
+        const ciphertext = ciphertextWithTag.slice(0, ciphertextWithTag.length - 16);
+        const decipher = createDecipheriv('aes-256-gcm', key, nonce);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        const str = decrypted.toString('utf-8');
+        const jsonStart = str.indexOf('%7B');
+        if (jsonStart >= 0)
+            return str.slice(jsonStart);
+        const rawJsonStart = str.indexOf('{');
+        if (rawJsonStart >= 0)
+            return str.slice(rawJsonStart);
+        throw new Error('Decrypted cookie data does not contain expected JSON value');
+    }
+    return encrypted.toString('utf-8');
+}
+// --- Cookie extraction ---
+function extractCookie(profilePath) {
+    const cookiesDb = join(profilePath, 'Cookies');
+    const tmpDir = mkdtempSync(join(tmpdir(), 'figmanage-'));
+    const tmpDb = join(tmpDir, 'Cookies');
+    // Copy DB + WAL/SHM (Chrome locks the original)
+    copyFileSync(cookiesDb, tmpDb);
+    for (const ext of ['-wal', '-shm']) {
+        const src = cookiesDb + ext;
+        if (existsSync(src))
+            copyFileSync(src, tmpDb + ext);
+    }
+    try {
+        // Query for the auth cookie -- could be on figma.com or www.figma.com
+        const sqliteBin = platform() === 'win32' ? 'sqlite3.exe' : 'sqlite3';
+        const hex = execSync(`${sqliteBin} "${tmpDb}" "SELECT hex(encrypted_value) FROM cookies WHERE name = '${COOKIE_NAME}' AND host_key LIKE '%figma.com' ORDER BY last_access_utc DESC LIMIT 1;"`, { encoding: 'utf-8' }).trim();
+        if (!hex)
+            throw new Error(`No ${COOKIE_NAME} cookie found. Are you logged into figma.com in Chrome?`);
+        const encrypted = Buffer.from(hex, 'hex');
+        const os = platform();
+        if (os === 'darwin') {
+            const key = getMacDecryptionKey();
+            return decryptCBC(encrypted, key);
+        }
+        else if (os === 'linux') {
+            const key = getLinuxDecryptionKey();
+            return decryptCBC(encrypted, key);
+        }
+        else if (os === 'win32') {
+            // Derive the chrome base from the profile path (go up one level from Default/Profile N)
+            const chromeBase = join(profilePath, '..');
+            const key = getWindowsDecryptionKey(chromeBase);
+            return decryptWindows(encrypted, key);
+        }
+        throw new Error(`Unsupported platform: ${os}`);
+    }
+    finally {
+        for (const f of [tmpDb, tmpDb + '-wal', tmpDb + '-shm']) {
+            try {
+                unlinkSync(f);
+            }
+            catch { }
+        }
+        try {
+            rmdirSync(tmpDir);
+        }
+        catch { }
+    }
+}
+// --- Figma API validation ---
+function parseCookieValue(raw) {
+    // Cookie value is JSON: {"userId":"token"} (may be URL-encoded)
+    let decoded = raw;
+    try {
+        decoded = decodeURIComponent(raw);
+    }
+    catch { }
+    try {
+        const parsed = JSON.parse(decoded);
+        const entries = Object.entries(parsed);
+        if (entries.length === 0)
+            throw new Error('Empty cookie JSON');
+        const [userId, token] = entries[0];
+        return { userId, token, cookieValue: raw };
+    }
+    catch {
+        throw new Error('Unexpected cookie format. Expected URL-encoded JSON with userId field.');
+    }
+}
+async function validateSession(cookieValue, userId) {
+    const headers = {
+        'Cookie': `${COOKIE_NAME}=${cookieValue}`,
+        'X-CSRF-Bypass': 'yes',
+        'X-Figma-User-Id': userId,
+    };
+    const res = await axios.get('https://www.figma.com/api/user/state', {
+        headers,
+        timeout: 15000,
+    });
+    if (res.data?.error !== false)
+        throw new Error('Session invalid');
+    const meta = res.data.meta || {};
+    const teams = (meta.teams || []).map((t) => ({ id: String(t.id), name: t.name }));
+    const orgs = (meta.orgs || []).map((o) => ({ id: String(o.id), name: o.name }));
+    // Try to find org_id: check orgs array, team_users, or follow the recents redirect
+    let orgId = '';
+    if (orgs.length > 0) {
+        orgId = orgs[0].id;
+    }
+    else {
+        // Figma redirects /files/recents-and-sharing to /files/{org_id}/recents-and-sharing
+        try {
+            const redirect = await axios.get('https://www.figma.com/files/recents-and-sharing', {
+                headers,
+                maxRedirects: 0,
+                validateStatus: (s) => s >= 200 && s < 400,
+                timeout: 10000,
+            });
+            // Check final URL for org_id pattern: /files/{org_id}/
+            const finalUrl = redirect.request?.res?.responseUrl || redirect.headers?.location || '';
+            const match = finalUrl.match(/\/files\/(\d+)\//);
+            if (match)
+                orgId = match[1];
+        }
+        catch (e) {
+            // Check redirect location header
+            const loc = e.response?.headers?.location || '';
+            const match = loc.match(/\/files\/(\d+)\//);
+            if (match)
+                orgId = match[1];
+        }
+    }
+    // If orgId found but no orgs entry, try to derive a name from the org's domain
+    if (orgId && orgs.length === 0) {
+        let name = orgId;
+        try {
+            const domRes = await axios.get(`https://www.figma.com/api/orgs/${orgId}/domains`, {
+                headers,
+                timeout: 10000,
+            });
+            const domains = domRes.data?.meta || [];
+            if (Array.isArray(domains) && domains.length > 0 && domains[0].domain) {
+                name = domains[0].domain;
+            }
+        }
+        catch { /* domain lookup optional */ }
+        orgs.push({ id: orgId, name });
+    }
+    return { orgId, orgs, teams };
+}
+// --- PAT validation ---
+async function validatePat(pat) {
+    const res = await axios.get('https://api.figma.com/v1/me', {
+        headers: { 'X-Figma-Token': pat },
+        timeout: 15000,
+    });
+    return res.data.handle || res.data.email || 'valid';
+}
+// --- MCP client detection and registration ---
+function claudeCliAvailable() {
+    try {
+        execSync('which claude 2>/dev/null || where claude 2>nul', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function registerWithClaude(envVars, serverPath) {
+    try {
+        execSync('claude mcp remove figmanage -s user 2>/dev/null || true', { encoding: 'utf-8' });
+        const envFlags = Object.entries(envVars).map(([k, v]) => `--env ${k}=${v}`).join(' ');
+        execSync(`claude mcp add figmanage --transport stdio -s user ${envFlags} -- node ${serverPath}`, { encoding: 'utf-8' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function printManualConfig(envVars, serverPath) {
+    console.log('\nClaude CLI not found. Configure your MCP client manually.\n');
+    console.log('Environment variables:');
+    for (const [k, v] of Object.entries(envVars)) {
+        const display = (k === 'FIGMA_AUTH_COOKIE' || k === 'FIGMA_PAT') ? '******' : v;
+        console.log(`  ${k}=${display}`);
+    }
+    console.log('\nMCP server config (JSON):');
+    const config = {
+        figmanage: {
+            command: 'node',
+            args: [serverPath],
+            env: Object.fromEntries(Object.entries(envVars).map(([k, v]) => [k, k === 'FIGMA_AUTH_COOKIE' || k === 'FIGMA_PAT' ? '<paste value>' : v])),
+        },
+    };
+    console.log(JSON.stringify(config, null, 2));
+}
+// --- CLI arg parsing ---
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let noPrompt = false;
+    let pat;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--no-prompt') {
+            noPrompt = true;
+        }
+        else if (args[i] === '--pat' && i + 1 < args.length) {
+            pat = args[++i];
+        }
+    }
+    return { noPrompt, pat };
+}
+// --- Main ---
+async function setup() {
+    console.log('figmanage setup\n');
+    const { noPrompt, pat: patArg } = parseArgs();
+    const os = platform();
+    // Build env vars to register
+    const envVars = {};
+    const serverPath = join(import.meta.dirname, 'index.js');
+    if (noPrompt) {
+        // Non-interactive mode: skip cookie extraction, require --pat
+        if (!patArg) {
+            console.error('--no-prompt requires --pat <token>');
+            process.exit(1);
+        }
+        console.log('Non-interactive mode. Validating PAT...');
+        try {
+            const patUser = await validatePat(patArg);
+            console.log(`  PAT valid (${patUser})`);
+            envVars.FIGMA_PAT = patArg;
+        }
+        catch {
+            console.error('  PAT invalid or expired.');
+            process.exit(1);
+        }
+        // Register with whatever client is available
+        if (claudeCliAvailable()) {
+            console.log('\nRegistering with Claude...');
+            if (registerWithClaude(envVars, serverPath)) {
+                console.log('  PAT stored in MCP server config');
+                console.log('  Done. Restart Claude Code to use figmanage.');
+            }
+            else {
+                printManualConfig(envVars, serverPath);
+            }
+        }
+        else {
+            printManualConfig(envVars, serverPath);
+        }
+        return;
+    }
+    // Interactive mode
+    if (os !== 'darwin' && os !== 'linux' && os !== 'win32') {
+        console.error(`Unsupported platform: ${os}. Provide credentials via --no-prompt --pat <token>.`);
+        process.exit(1);
+    }
+    // 1. Extract cookies from all Chrome profiles
+    const promptLabel = os === 'darwin' ? ' (Keychain prompt may appear)' : '';
+    console.log(`Reading Chrome cookies${promptLabel}...`);
+    let accounts = [];
+    try {
+        const profiles = findChromeProfiles();
+        for (const profilePath of profiles) {
+            try {
+                const rawCookie = extractCookie(profilePath);
+                const { userId, cookieValue } = parseCookieValue(rawCookie);
+                accounts.push({ userId, cookieValue, profile: profilePath.split(/[/\\]/).pop() });
+            }
+            catch {
+                // Profile doesn't have a Figma cookie
+            }
+        }
+    }
+    catch (e) {
+        if (os === 'win32') {
+            console.log(`  Cookie extraction failed: ${e.message}`);
+            console.log('  Windows cookie extraction is best-effort. Provide credentials manually.');
+            console.log('  You can still enter a PAT below.\n');
+        }
+        else {
+            throw e;
+        }
+    }
+    let userId = '';
+    let cookieValue = '';
+    if (accounts.length === 0) {
+        if (os === 'win32') {
+            console.log('  No Figma auth cookies extracted. Continuing with PAT-only setup.');
+        }
+        else {
+            console.error('No Figma auth cookies found. Log into figma.com in Chrome.');
+            process.exit(1);
+        }
+    }
+    else {
+        // If multiple accounts, let user pick
+        let selected = accounts[0];
+        if (accounts.length > 1) {
+            console.log(`\n  Found ${accounts.length} Figma accounts:\n`);
+            for (let i = 0; i < accounts.length; i++) {
+                const a = accounts[i];
+                console.log(`  [${i + 1}] User ${a.userId} (${a.profile})`);
+            }
+            const { createInterface } = await import('readline');
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => {
+                rl.question(`\n  Select account [1-${accounts.length}]: `, resolve);
+            });
+            rl.close();
+            const idx = parseInt(answer, 10) - 1;
+            if (idx < 0 || idx >= accounts.length) {
+                console.error('  Invalid selection.');
+                process.exit(1);
+            }
+            selected = accounts[idx];
+        }
+        userId = selected.userId;
+        cookieValue = selected.cookieValue;
+        console.log(`  Cookie found for user ${userId}`);
+    }
+    // 2. Validate cookie against Figma (if we have one)
+    let orgId = '';
+    let orgs = [];
+    if (cookieValue && userId) {
+        console.log('Validating session...');
+        try {
+            const session = await validateSession(cookieValue, userId);
+            console.log(`  Session valid (user ${userId})`);
+            if (session.teams.length > 0) {
+                console.log(`  Teams: ${session.teams.map(t => t.name).join(', ')}`);
+            }
+            orgId = session.orgId;
+            orgs = session.orgs;
+        }
+        catch (e) {
+            const status = e.response?.status;
+            if (status === 401 || status === 403) {
+                console.error('  Cookie expired. Log into figma.com in Chrome and try again.');
+            }
+            else {
+                console.error(`  Validation failed: ${e.message}`);
+            }
+            process.exit(1);
+        }
+        if (orgs.length > 1) {
+            console.log(`\n  Found ${orgs.length} workspaces:\n`);
+            for (let i = 0; i < orgs.length; i++) {
+                const o = orgs[i];
+                const marker = o.id === orgId ? ' (current)' : '';
+                console.log(`  [${i + 1}] ${o.name} (${o.id})${marker}`);
+            }
+            const { createInterface } = await import('readline');
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => {
+                rl.question(`\n  Default workspace [1-${orgs.length}] (Enter for 1): `, resolve);
+            });
+            rl.close();
+            const input = answer.trim();
+            if (input) {
+                const idx = parseInt(input, 10) - 1;
+                if (idx >= 0 && idx < orgs.length) {
+                    orgId = orgs[idx].id;
+                }
+            }
+        }
+        if (orgId) {
+            const orgName = orgs.find(o => o.id === orgId)?.name;
+            console.log(`  Workspace: ${orgName ? `${orgName} (${orgId})` : orgId}`);
+        }
+        // Store cookie credentials
+        envVars.FIGMA_AUTH_COOKIE = cookieValue;
+        envVars.FIGMA_USER_ID = userId;
+        if (orgId)
+            envVars.FIGMA_ORG_ID = orgId;
+        if (orgs.length > 0)
+            envVars.FIGMA_ORGS = JSON.stringify(orgs);
+    }
+    // 3. PAT: arg > env > prompt
+    let pat = patArg || process.env.FIGMA_PAT || '';
+    if (pat) {
+        console.log('Validating PAT...');
+        try {
+            const patUser = await validatePat(pat);
+            console.log(`  PAT valid (${patUser})`);
+        }
+        catch {
+            console.log('  PAT invalid or expired.');
+            pat = '';
+        }
+    }
+    if (!pat) {
+        console.log('\nA Personal Access Token enables comments, export, and version history.');
+        console.log('Generate one at: https://www.figma.com/settings (Security > Personal access tokens)');
+        const { createInterface } = await import('readline');
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve) => {
+            rl.question('Paste your PAT (or press Enter to skip): ', resolve);
+        });
+        rl.close();
+        pat = answer.trim();
+        if (pat) {
+            try {
+                const patUser = await validatePat(pat);
+                console.log(`  PAT valid (${patUser})`);
+            }
+            catch {
+                console.log('  PAT invalid -- skipping');
+                pat = '';
+            }
+        }
+    }
+    if (pat) {
+        envVars.FIGMA_PAT = pat;
+    }
+    // Must have at least one credential
+    if (!envVars.FIGMA_PAT && !envVars.FIGMA_AUTH_COOKIE) {
+        console.error('\nNo credentials configured. Need at least a PAT or browser cookie.');
+        process.exit(1);
+    }
+    // 4. Register with MCP client
+    console.log('\n--- Configuration ---\n');
+    console.log(`FIGMA_USER_ID=${userId || '(none)'}`);
+    console.log('FIGMA_AUTH_COOKIE=****** (stored in MCP server config)');
+    if (orgId)
+        console.log(`FIGMA_ORG_ID=${orgId}`);
+    if (pat)
+        console.log('FIGMA_PAT=****** (stored in MCP server config)');
+    if (claudeCliAvailable()) {
+        console.log('\nRegistering with Claude...');
+        if (registerWithClaude(envVars, serverPath)) {
+            if (pat)
+                console.log('  PAT stored in MCP server config');
+            console.log('  Done. Restart Claude Code to use figmanage.');
+        }
+        else {
+            console.log('  Could not register automatically.');
+            printManualConfig(envVars, serverPath);
+        }
+    }
+    else {
+        printManualConfig(envVars, serverPath);
+    }
+}
+setup().catch((err) => {
+    console.error(`\nSetup failed: ${err.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=setup.js.map

package/dist/tools/analytics.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=analytics.d.ts.map