From c5bf4b57e4f42c05a4939350ac23255d1a333618 Mon Sep 17 00:00:00 2001 From: ivanhelloprint Date: Tue, 3 Mar 2026 16:55:22 +0100 Subject: [PATCH] Add use-figma skill with Figma API tool scripts Includes 6 Node.js scripts for extracting design specs from Figma (layout, typography, colors, screenshots, tokens, code connect map). README explains API token setup. --- use-figma/README.md | 45 ++ use-figma/SKILL.md | 119 +++++ use-figma/scripts/get-code-connect-map.mjs | 390 ++++++++++++++ use-figma/scripts/get-design-context.mjs | 484 ++++++++++++++++++ use-figma/scripts/get-metadata.mjs | 469 +++++++++++++++++ use-figma/scripts/get-screenshot.mjs | 387 ++++++++++++++ .../scripts/get-variable-definitions.mjs | 404 +++++++++++++++ use-figma/scripts/whoami.mjs | 276 ++++++++++ 8 files changed, 2574 insertions(+) create mode 100644 use-figma/README.md create mode 100644 use-figma/SKILL.md create mode 100755 use-figma/scripts/get-code-connect-map.mjs create mode 100755 use-figma/scripts/get-design-context.mjs create mode 100755 use-figma/scripts/get-metadata.mjs create mode 100755 use-figma/scripts/get-screenshot.mjs create mode 100755 use-figma/scripts/get-variable-definitions.mjs create mode 100755 use-figma/scripts/whoami.mjs diff --git a/use-figma/README.md b/use-figma/README.md new file mode 100644 index 0000000..0312d8f --- /dev/null +++ b/use-figma/README.md @@ -0,0 +1,45 @@ +# use-figma + +Figma design tools for extracting specs and implementing pixel-perfect designs. + +## Setup + +### 1. Get a Figma API token + +1. Go to [Figma Account Settings](https://www.figma.com/developers/api#access-tokens) +2. Generate a new **Personal Access Token** +3. Required scopes: `file_read` +4. Optional scopes: `file_variables:read` (needed for `get-variable-definitions`) + +### 2. Configure the token + +Create a `.env.tools` file in your project root: + +``` +FIGMA_ACCESS_TOKEN=your_token_here +``` + +Make sure `.env.tools` is in your `.gitignore` — never commit tokens. + +### 3. Verify it works + +```bash +node use-figma/scripts/whoami.mjs --verbose +``` + +You should see your Figma user info if the token is valid. + +## Available Scripts + +| Script | Description | +|---|---| +| `whoami.mjs` | Verify API token authentication | +| `get-design-context.mjs` | Extract layout, spacing, colors, typography | +| `get-metadata.mjs` | Get node hierarchy and constraints | +| `get-screenshot.mjs` | Generate visual screenshots from designs | +| `get-code-connect-map.mjs` | Check which components are linked to code | +| `get-variable-definitions.mjs` | Extract design tokens (colors, spacing, typography) | + +## Usage + +See `SKILL.md` for the full workflow on how these tools are used together. diff --git a/use-figma/SKILL.md b/use-figma/SKILL.md new file mode 100644 index 0000000..8ba9f88 --- /dev/null +++ b/use-figma/SKILL.md @@ -0,0 +1,119 @@ +--- +name: use-figma +description: > + Fetch Figma design specs for pixel-perfect implementation. Triggers - Figma URL provided, + match the design, implement this Figma, from the mockup, design specs, pixel-perfect, + exact spacing/typography/colors needed. +--- + +# Figma Design Tools + +This skill ships with Figma helper scripts under `use-figma/scripts/`. + +## Prerequisites + +- Set `FIGMA_ACCESS_TOKEN` in a `.env.tools` file at the project root (see `use-figma/README.md`). +- Use the scripts from this skill directory (do not assume a `js/bin` folder). + +## When to use this skill + +Use when: + +- The user provides a **Figma URL** (design / node / section link) +- The request says "match Figma" / "implement this design" / "pixel-perfect" +- You need **exact spacing/typography/colors/states** (not "close enough") + +## Workflow + +### When a Figma URL is provided + +1. **Extract EXACT Specifications** (MANDATORY) + + Run the tools in sequence: + + ```bash + # 1. Verify token works + node use-figma/scripts/whoami.mjs --verbose + + # 2. Get layout, spacing, colors, typography + node use-figma/scripts/get-design-context.mjs \ + --url "https://www.figma.com/design/..." \ + --include-images \ + --verbose + + # 3. Get node hierarchy and constraints + node use-figma/scripts/get-metadata.mjs \ + --url "https://www.figma.com/design/..." \ + --verbose + + # 4. Get a visual screenshot for reference + node use-figma/scripts/get-screenshot.mjs \ + --url "https://www.figma.com/design/..." \ + --format png \ + --scale 2 \ + --verbose + ``` + + **Output handling (required)** + - If the output includes an `errors` array, it must be empty before using the data. + - Capture a short "design spec note" before coding: + - typography (fontSize/fontWeight/lineHeight) + - spacing (padding/margins/gaps) + - colors (tokens/variables or exact values) + - border radius, shadows + - states (hover/focus/active/disabled/empty/loading) + +2. **Document ALL Measurements Before Writing Code** + + Extract and note: + - **Typography**: `fontSize`, `fontWeight`, `lineHeight` for EVERY text element + - **Spacing**: Exact margins, paddings, gaps from auto-layout values + - **Colors**: Hex/RGB values — no approximations + - **Dimensions**: Precise width/height/aspect-ratio values + - **Border radius**: `cornerRadius` values + - **Shadows**: `effects` array for box shadows + - **States**: Document hover, focus, active, disabled, empty states + +3. **Check Existing Patterns** + + Before implementing, check if similar components exist: + + ```bash + # Check which Figma components are already linked to code + node use-figma/scripts/get-code-connect-map.mjs \ + --file-key \ + --verbose + ``` + +4. **Implement with EXACT Values** + + - Use exact Figma values, not approximations + - Prefer existing design tokens; if no token exists, use the exact value and leave a short comment referencing the Figma node / measurement + - Implement ALL interactive states from the design + +5. **Validate** + + Before finishing: + - [ ] Typography matches Figma exactly (font size, weight, line height) + - [ ] Spacing matches Figma exactly (margins, padding, gaps) + - [ ] Colors match Figma exactly (use hex values from design) + - [ ] All interactive states implemented (hover, focus, active, disabled) + - [ ] Responsive behavior matches design intent + +## Additional Commands + +```bash +# Get design tokens (colors, spacing, typography variables) +node use-figma/scripts/get-variable-definitions.mjs \ + --file-key \ + --include-styles true \ + --verbose +``` + +## Rules + +- **NEVER approximate** — use exact values from Figma +- **ALWAYS document measurements** before writing any code +- **Check `errors` array** is empty before using response data +- **Ask for clarification** if the design is ambiguous or states are missing +- **Reference existing patterns** before creating new components diff --git a/use-figma/scripts/get-code-connect-map.mjs b/use-figma/scripts/get-code-connect-map.mjs new file mode 100755 index 0000000..2ccc01d --- /dev/null +++ b/use-figma/scripts/get-code-connect-map.mjs @@ -0,0 +1,390 @@ +#!/usr/bin/env node + +// coding-tools/figma-tools/js/src/get-code-connect-map.ts +import { readFile } from "node:fs/promises"; +import path from "node:path"; + +// coding-tools/figma-tools/js/src/_utils/cli-args.ts +function parseArgs(argv = process.argv.slice(2)) { + const args = { _: [] }; + for (let i = 0; i < argv.length; i += 1) { + const arg = argv[i]; + if (!arg.startsWith("-") || arg === "-") { + args._.push(arg); + continue; + } + if (arg === "--") { + const remaining = argv.slice(i + 1); + args._.push(...remaining); + break; + } + const [rawKey, inlineValue] = arg.split("=", 2); + const normalisedKey = rawKey.replace(/^-+/, ""); + let value; + if (inlineValue !== void 0) { + value = inlineValue; + } else { + const next = argv[i + 1]; + if (next !== void 0 && !next.startsWith("-")) { + value = next; + i += 1; + } else { + value = true; + } + } + args[normalisedKey] = value; + } + return args; +} + +// coding-tools/figma-tools/js/src/_utils/url-parse.ts +var FILE_KEY_REGEX = /figma\.com\/(?:file|design)\/([A-Za-z0-9]+)\//i; +function parseFigmaUrl(input) { + if (!input) return { fileKey: null, nodeId: null }; + try { + const url = new URL(input); + const match = url.href.match(FILE_KEY_REGEX); + const fileKey = match ? match[1] : null; + const nodeParam = url.searchParams.get("node-id"); + const nodeId = nodeParam ? ensureNodeId(nodeParam) : null; + return { fileKey, nodeId }; + } catch { + return { fileKey: null, nodeId: null }; + } +} +function ensureNodeId(value) { + if (!value) return null; + const decoded = decodeURIComponent(value); + if (decoded.includes(":")) return decoded; + if (/^[0-9]+-[0-9]+$/.test(decoded)) { + const [left, right] = decoded.split("-", 2); + return `${left}:${right}`; + } + return decoded; +} + +// coding-tools/figma-tools/js/src/_utils/config.ts +var config_default = { + schemaVersion: "1.0.0", + source: "agentic-coding-templates/figma-tools", + http: { + maxAttempts: 5, + initialDelayMs: 250 + } +}; + +// coding-tools/figma-tools/js/src/_utils/envelope.ts +function buildRateLimitMeta(rateLimit = {}) { + return { + remaining: rateLimit.remaining ?? null, + resetAt: rateLimit.resetAt ?? null, + attempts: rateLimit.attempts ?? 1, + lastWaitMs: rateLimit.lastWaitMs ?? 0 + }; +} +function createEnvelope({ + tool, + input = {}, + data = {}, + warnings = [], + errors = [], + rateLimit, + schemaVersion +}) { + return { + schemaVersion: schemaVersion ?? config_default.schemaVersion, + tool, + input, + meta: { + generatedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: config_default.source, + rateLimit: buildRateLimitMeta(rateLimit) + }, + data, + warnings, + errors + }; +} + +// coding-tools/figma-tools/js/src/_utils/errors.ts +var ERROR_EXIT_CODES = { + INPUT_INVALID: 1, + CONFIG_INVALID: 1, + FIGMA_AUTH: 1, + FIGMA_NOT_FOUND: 2, + FIGMA_RATE_LIMIT: 2, + NETWORK: 2, + INTERNAL: 3 +}; +function createError(code, message, detail) { + return { + code, + message, + detail: detail ?? null + }; +} +function getExitCode(errors = []) { + if (!errors.length) { + return 0; + } + return errors.reduce((max, error) => { + const exitCode = ERROR_EXIT_CODES[error.code] ?? 1; + return Math.max(max, exitCode); + }, 0); +} + +// coding-tools/figma-tools/js/src/_utils/http-client.ts +var BASE_URL = "https://api.figma.com"; +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} +function parseJsonSafely(text) { + try { + return text ? JSON.parse(text) : {}; + } catch { + return { raw: text }; + } +} +function parseRateLimit(headers, attempts, lastWaitMs) { + const remainingHeader = headers.get("x-ratelimit-remaining"); + const resetHeader = headers.get("x-ratelimit-reset"); + let remaining = null; + if (remainingHeader !== null && remainingHeader !== void 0) { + const parsed = Number(remainingHeader); + remaining = Number.isNaN(parsed) ? null : parsed; + } + let resetAt = null; + if (resetHeader) { + const numericReset = Number(resetHeader); + if (!Number.isNaN(numericReset)) { + resetAt = new Date(numericReset * 1e3).toISOString(); + } else { + const date = new Date(resetHeader); + if (!Number.isNaN(date.valueOf())) { + resetAt = date.toISOString(); + } + } + } + return { + remaining, + resetAt, + attempts, + lastWaitMs + }; +} +function computeBackoffMs(attempt, initialDelayMs) { + return initialDelayMs * 2 ** (attempt - 1); +} +async function figmaRequest(options) { + const { + path: path2, + method = "GET", + token, + headers = {}, + body, + searchParams, + maxAttempts = config_default.http?.maxAttempts ?? 5, + initialDelayMs = config_default.http?.initialDelayMs ?? 250 + } = options; + if (!token) { + return { + ok: false, + error: createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is missing from the environment."), + status: null, + rateLimit: null + }; + } + const url = new URL(path2, BASE_URL); + if (searchParams) { + Object.entries(searchParams).forEach(([key, value]) => { + if (value === void 0 || value === null) return; + url.searchParams.append(key, String(value)); + }); + } + let attempt = 0; + let lastWaitMs = 0; + while (attempt < maxAttempts) { + attempt += 1; + const response = await fetch(url, { + method, + headers: { + "Content-Type": "application/json", + "X-Figma-Token": token, + ...headers + }, + body: body ? JSON.stringify(body) : void 0 + }); + const text = await response.text(); + const payload = parseJsonSafely(text); + const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs); + if (response.ok) { + return { ok: true, data: payload, rateLimit }; + } + const status = response.status; + if (status === 401 || status === 403) { + return { ok: false, error: createError("FIGMA_AUTH", payload?.message ?? "Figma token is unauthorized.", { status }), status, rateLimit }; + } + if (status === 404) { + return { ok: false, error: createError("FIGMA_NOT_FOUND", payload?.message ?? "Resource not found.", { status }), status, rateLimit }; + } + if (status === 429 || status >= 500) { + if (attempt >= maxAttempts) { + return { + ok: false, + error: createError(status === 429 ? "FIGMA_RATE_LIMIT" : "NETWORK", payload?.message ?? "Figma request failed after maximum retries.", { status }), + status, + rateLimit + }; + } + let waitMs = computeBackoffMs(attempt, initialDelayMs); + const resetHeader = response.headers.get("x-ratelimit-reset"); + if (resetHeader) { + const asNumber = Number(resetHeader); + if (!Number.isNaN(asNumber)) { + const resetMs = asNumber * 1e3; + const delta = resetMs - Date.now(); + if (delta > 0) waitMs = Math.max(waitMs, delta); + } + } + const jitter = Math.floor(Math.random() * 100); + lastWaitMs = waitMs + jitter; + await sleep(lastWaitMs); + continue; + } + return { ok: false, error: createError("INTERNAL", payload?.message ?? "Unexpected error from Figma API.", { status }), status, rateLimit }; + } + return { + ok: false, + error: createError("NETWORK", "Unable to reach Figma API."), + status: null, + rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs } + }; +} + +// coding-tools/figma-tools/js/src/get-code-connect-map.ts +var TOOL_NAME = "get-code-connect-map"; +function log(message, verbose) { + if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message} +`); +} +function toOptionalString(value) { + return typeof value === "string" && value.length > 0 ? value : null; +} +function exitWithEnvelope(envelope, errors = []) { + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +async function readRepoConfig() { + try { + const configPath = path.resolve("config/code-connect-map.json"); + const content = await readFile(configPath, "utf8"); + const parsed = JSON.parse(content); + if (parsed && Array.isArray(parsed.components)) return parsed; + return { version: "0.1", components: [] }; + } catch { + return { version: "0.1", components: [] }; + } +} +async function main() { + const args = parseArgs(); + const verbose = Boolean(args.verbose ?? args.v); + const schemaVersion = toOptionalString(args["schema-version"]) ?? void 0; + const warnings = []; + const errors = []; + let repoConfig = { version: "0.1", components: [] }; + try { + repoConfig = await readRepoConfig(); + } catch (error) { + warnings.push(error instanceof Error ? error.message : String(error)); + } + const token = process.env.FIGMA_ACCESS_TOKEN; + if (!token || !token.trim()) { + errors.push(createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is required but was not provided.")); + const envelope2 = createEnvelope({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null }, warnings, errors, schemaVersion, data: {} }); + exitWithEnvelope(envelope2, errors); + } + const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u); + let fileKey = toOptionalString(args["file-key"]) ?? void 0; + const nodeIdInput = ensureNodeId(toOptionalString(args["node-id"])); + if (urlInput) { + const parsed = parseFigmaUrl(urlInput); + fileKey = fileKey || parsed.fileKey || void 0; + } + const input = { fileKey: fileKey ?? null, nodeId: nodeIdInput ?? null }; + if (!fileKey) errors.push(createError("INPUT_INVALID", "A valid Figma file key is required (--file-key or --url).")); + if (errors.length) { + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + const resolvedFileKey = fileKey; + log("Fetching dev resources", verbose); + const devResourcesResponse = await figmaRequest({ path: `/v1/files/${resolvedFileKey}/devresources`, token }); + log("Fetching components", verbose); + const componentsResponse = await figmaRequest({ path: `/v1/files/${resolvedFileKey}/components`, token }); + if (!devResourcesResponse.ok) { + errors.push(devResourcesResponse.error ?? createError("INTERNAL", "Failed to fetch dev resources.")); + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, rateLimit: devResourcesResponse.rateLimit ?? void 0, schemaVersion, data: {} }); + exitWithEnvelope(envelope2, errors); + } + if (!componentsResponse.ok) warnings.push(componentsResponse.error?.message ?? "Failed to fetch components."); + const devResources = devResourcesResponse.data?.dev_resources ?? []; + const componentsMap = componentsResponse.ok ? componentsResponse.data?.components ?? {} : {}; + const repoMappings = repoConfig.components ?? []; + const normalisedResources = devResources.map((resource) => ({ + id: resource.id, + name: resource.name, + description: resource.description ?? null, + url: resource.url ?? null, + nodeId: resource.node_id ?? null, + componentId: resource.component_id ?? null, + fileKey: resource.file_key ?? resolvedFileKey, + status: resource.status ?? null, + createdAt: resource.created_at ?? null, + updatedAt: resource.updated_at ?? null + })); + const normalisedComponents = Object.entries(componentsMap).map(([componentId, component]) => ({ + id: componentId, + key: component.key, + name: component.name, + description: component.description ?? null, + fileKey: component.file_key ?? resolvedFileKey, + nodeId: component.node_id ?? null + })); + const findRepoMapping = (name) => { + if (!name) return null; + return repoMappings.find((m) => m.name === name || m.component === name) ?? null; + }; + const mappings = normalisedResources.map((resource) => { + const component = resource.componentId ? normalisedComponents.find((entry) => entry.id === resource.componentId) : null; + const repoMapping = findRepoMapping(component?.name ?? resource.name); + if (!repoMapping) { + warnings.push(`Node ${resource.nodeId ?? component?.nodeId ?? "unknown"} (${resource.name ?? component?.name ?? "unnamed"}) has no mapping in config/code-connect-map.json.`); + } + return { + nodeId: resource.nodeId ?? component?.nodeId ?? null, + componentId: resource.componentId ?? component?.id ?? null, + componentKey: component?.key ?? null, + componentName: component?.name ?? resource.name ?? null, + repoComponent: repoMapping?.component ?? null, + repoPath: repoMapping?.path ?? null, + props: repoMapping?.props ?? null, + description: component?.description ?? resource.description ?? null, + status: resource.status ?? null, + sourceUrl: resource.url ?? null + }; + }); + const data = { file: { key: resolvedFileKey }, mappings, components: normalisedComponents, devResources: normalisedResources }; + const envelope = createEnvelope({ tool: TOOL_NAME, input, data, warnings, errors, rateLimit: devResourcesResponse.rateLimit ?? void 0, schemaVersion }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +main().catch((error) => { + const message = error instanceof Error ? error.message : "Unknown error"; + const envelope = createEnvelope({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null }, errors: [createError("INTERNAL", message, { stack: error instanceof Error ? error.stack : void 0 })], data: {} }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(3); +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/get-code-connect-map.ts", "../src/_utils/cli-args.ts", "../src/_utils/url-parse.ts", "../src/_utils/config.ts", "../src/_utils/envelope.ts", "../src/_utils/errors.ts", "../src/_utils/http-client.ts"],
  "sourcesContent": ["#!/usr/bin/env node\n\nimport { readFile } from 'node:fs/promises'\nimport path from 'node:path'\nimport { parseArgs, type CliArgs } from './_utils/cli-args.ts'\nimport { parseFigmaUrl, ensureNodeId } from './_utils/url-parse.ts'\nimport { createEnvelope, type ToolEnvelope } from './_utils/envelope.ts'\nimport { createError, getExitCode, type ToolError } from './_utils/errors.ts'\nimport { figmaRequest } from './_utils/http-client.ts'\n\nconst TOOL_NAME = 'get-code-connect-map'\ntype EmptyData = Record<string, never>\n\ninterface ToolInput extends Record<string, unknown> { fileKey: string | null; nodeId: string | null }\n\ninterface RepoComponentMapping { name?: string; component?: string; path?: string; props?: Record<string, unknown> }\ninterface RepoConfig { version?: string; components?: RepoComponentMapping[] }\n\ninterface DevResourcePayload { dev_resources?: DevResource[] }\ninterface DevResource { id: string; name?: string; description?: string; url?: string; node_id?: string; component_id?: string; file_key?: string; status?: string; created_at?: string; updated_at?: string }\ninterface NormalisedDevResource { id: string; name?: string; description: string | null; url: string | null; nodeId: string | null; componentId: string | null; fileKey: string; status: string | null; createdAt: string | null; updatedAt: string | null }\n\ninterface ComponentMeta { key?: string; name?: string; description?: string; file_key?: string; node_id?: string }\ninterface ComponentsPayload { components?: Record<string, ComponentMeta> }\ninterface NormalisedComponent { id: string; key?: string; name?: string; description: string | null; fileKey: string; nodeId: string | null }\n\ninterface Mapping { nodeId: string | null; componentId: string | null; componentKey: string | null; componentName: string | null; repoComponent: string | null; repoPath: string | null; props: Record<string, unknown> | null; description: string | null; status: string | null; sourceUrl: string | null }\n\ninterface CodeConnectData { file: { key: string }; mappings: Mapping[]; components: NormalisedComponent[]; devResources: NormalisedDevResource[] }\n\nfunction log(message: string, verbose: boolean): void { if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message}\\n`) }\nfunction toOptionalString(value: CliArgs[string]): string | null { return typeof value === 'string' && value.length > 0 ? value : null }\nfunction exitWithEnvelope(envelope: ToolEnvelope<ToolInput, CodeConnectData | EmptyData>, errors: ToolError[] = []): never { process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`); process.exit(getExitCode(errors)) }\n\nasync function readRepoConfig(): Promise<RepoConfig> {\n  try {\n    const configPath = path.resolve('config/code-connect-map.json')\n    const content = await readFile(configPath, 'utf8')\n    const parsed = JSON.parse(content)\n    if (parsed && Array.isArray(parsed.components)) return parsed\n    return { version: '0.1', components: [] }\n  } catch {\n    return { version: '0.1', components: [] }\n  }\n}\n\nasync function main(): Promise<void> {\n  const args = parseArgs()\n  const verbose = Boolean(args.verbose ?? args.v)\n  const schemaVersion = toOptionalString(args['schema-version']) ?? undefined\n\n  const warnings: string[] = []\n  const errors: ToolError[] = []\n\n  let repoConfig: RepoConfig = { version: '0.1', components: [] }\n  try { repoConfig = await readRepoConfig() } catch (error) { warnings.push(error instanceof Error ? error.message : String(error)) }\n\n  const token = process.env.FIGMA_ACCESS_TOKEN\n  if (!token || !token.trim()) {\n    errors.push(createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is required but was not provided.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null }, warnings, errors, schemaVersion, data: {} as EmptyData })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u)\n  let fileKey = toOptionalString(args['file-key']) ?? undefined\n  const nodeIdInput = ensureNodeId(toOptionalString(args['node-id']))\n  if (urlInput) { const parsed = parseFigmaUrl(urlInput); fileKey = fileKey || parsed.fileKey || undefined }\n\n  const input: ToolInput = { fileKey: fileKey ?? null, nodeId: nodeIdInput ?? null }\n  if (!fileKey) errors.push(createError('INPUT_INVALID', 'A valid Figma file key is required (--file-key or --url).'))\n  if (errors.length) { const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, data: {} as EmptyData, schemaVersion }); exitWithEnvelope(envelope, errors) }\n\n  const resolvedFileKey = fileKey as string\n\n  log('Fetching dev resources', verbose)\n  const devResourcesResponse = await figmaRequest<DevResourcePayload>({ path: `/v1/files/${resolvedFileKey}/devresources`, token })\n  log('Fetching components', verbose)\n  const componentsResponse = await figmaRequest<ComponentsPayload>({ path: `/v1/files/${resolvedFileKey}/components`, token })\n\n  if (!devResourcesResponse.ok) {\n    errors.push(devResourcesResponse.error ?? createError('INTERNAL', 'Failed to fetch dev resources.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, rateLimit: devResourcesResponse.rateLimit ?? undefined, schemaVersion, data: {} as EmptyData })\n    exitWithEnvelope(envelope, errors)\n  }\n  if (!componentsResponse.ok) warnings.push(componentsResponse.error?.message ?? 'Failed to fetch components.')\n\n  const devResources = devResourcesResponse.data?.dev_resources ?? []\n  const componentsMap: Record<string, ComponentMeta> = componentsResponse.ok ? componentsResponse.data?.components ?? {} : {}\n  const repoMappings = repoConfig.components ?? []\n\n  const normalisedResources: NormalisedDevResource[] = devResources.map((resource: DevResource) => ({\n    id: resource.id,\n    name: resource.name,\n    description: resource.description ?? null,\n    url: resource.url ?? null,\n    nodeId: resource.node_id ?? null,\n    componentId: resource.component_id ?? null,\n    fileKey: resource.file_key ?? resolvedFileKey,\n    status: resource.status ?? null,\n    createdAt: resource.created_at ?? null,\n    updatedAt: resource.updated_at ?? null,\n  }))\n\n  const normalisedComponents: NormalisedComponent[] = Object.entries(componentsMap).map(([componentId, component]) => ({\n    id: componentId,\n    key: component.key,\n    name: component.name,\n    description: component.description ?? null,\n    fileKey: component.file_key ?? resolvedFileKey,\n    nodeId: component.node_id ?? null,\n  }))\n\n  const findRepoMapping = (name?: string | null) => {\n    if (!name) return null\n    return repoMappings.find((m) => m.name === name || m.component === name) ?? null\n  }\n\n  const mappings: Mapping[] = normalisedResources.map((resource) => {\n    const component = resource.componentId ? normalisedComponents.find((entry) => entry.id === resource.componentId) : null\n    const repoMapping = findRepoMapping(component?.name ?? resource.name)\n    if (!repoMapping) {\n      warnings.push(`Node ${resource.nodeId ?? component?.nodeId ?? 'unknown'} (${resource.name ?? component?.name ?? 'unnamed'}) has no mapping in config/code-connect-map.json.`)\n    }\n    return {\n      nodeId: resource.nodeId ?? component?.nodeId ?? null,\n      componentId: resource.componentId ?? component?.id ?? null,\n      componentKey: component?.key ?? null,\n      componentName: component?.name ?? resource.name ?? null,\n      repoComponent: repoMapping?.component ?? null,\n      repoPath: repoMapping?.path ?? null,\n      props: repoMapping?.props ?? null,\n      description: component?.description ?? resource.description ?? null,\n      status: resource.status ?? null,\n      sourceUrl: resource.url ?? null,\n    }\n  })\n\n  const data: CodeConnectData = { file: { key: resolvedFileKey }, mappings, components: normalisedComponents, devResources: normalisedResources }\n\n  const envelope = createEnvelope<ToolInput, CodeConnectData>({ tool: TOOL_NAME, input, data, warnings, errors, rateLimit: devResourcesResponse.rateLimit ?? undefined, schemaVersion })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nmain().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : 'Unknown error'\n  const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null }, errors: [createError('INTERNAL', message, { stack: error instanceof Error ? error.stack : undefined })], data: {} as EmptyData })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(3)\n})\n\n", "export type CliArgValue = string | boolean;\n\nexport interface CliArgs {\n  _: string[];\n  [key: string]: CliArgValue | string[];\n}\n\nexport function parseArgs(argv: string[] = process.argv.slice(2)): CliArgs {\n  const args: CliArgs = { _: [] };\n\n  for (let i = 0; i < argv.length; i += 1) {\n    const arg = argv[i];\n\n    if (!arg.startsWith('-') || arg === '-') {\n      args._.push(arg);\n      continue;\n    }\n\n    if (arg === '--') {\n      const remaining = argv.slice(i + 1);\n      args._.push(...remaining);\n      break;\n    }\n\n    const [rawKey, inlineValue] = arg.split('=', 2);\n    const normalisedKey = rawKey.replace(/^-+/, '');\n\n    let value: CliArgValue;\n    if (inlineValue !== undefined) {\n      value = inlineValue;\n    } else {\n      const next = argv[i + 1];\n      if (next !== undefined && !next.startsWith('-')) {\n        value = next;\n        i += 1;\n      } else {\n        value = true;\n      }\n    }\n\n    args[normalisedKey] = value;\n  }\n\n  return args;\n}\n\n", "const FILE_KEY_REGEX = /figma\\.com\\/(?:file|design)\\/([A-Za-z0-9]+)\\//i;\n\nexport interface ParsedFigmaUrl {\n  fileKey: string | null;\n  nodeId: string | null;\n}\n\nexport function parseFigmaUrl(input: string | null | undefined): ParsedFigmaUrl {\n  if (!input) return { fileKey: null, nodeId: null };\n  try {\n    const url = new URL(input);\n    const match = url.href.match(FILE_KEY_REGEX);\n    const fileKey = match ? match[1] : null;\n    const nodeParam = url.searchParams.get('node-id');\n    const nodeId = nodeParam ? ensureNodeId(nodeParam) : null;\n    return { fileKey, nodeId };\n  } catch {\n    return { fileKey: null, nodeId: null };\n  }\n}\n\nexport function ensureNodeId(value: string | null | undefined): string | null {\n  if (!value) return null;\n  const decoded = decodeURIComponent(value);\n  if (decoded.includes(':')) return decoded;\n  if (/^[0-9]+-[0-9]+$/.test(decoded)) {\n    const [left, right] = decoded.split('-', 2);\n    return `${left}:${right}`;\n  }\n  return decoded;\n}\n\n", "export default {\n  schemaVersion: '1.0.0',\n  source: 'agentic-coding-templates/figma-tools',\n  http: {\n    maxAttempts: 5,\n    initialDelayMs: 250,\n  },\n} as const;\n\n", "import config from './config.ts';\nimport type { ToolError } from './errors.ts';\n\nexport interface RateLimitMeta {\n  remaining: number | null;\n  resetAt: string | null;\n  attempts: number;\n  lastWaitMs: number;\n}\n\nexport interface ToolEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  schemaVersion: string;\n  tool: string;\n  input: TInput;\n  meta: {\n    generatedAt: string;\n    source: string;\n    rateLimit: RateLimitMeta;\n  };\n  data: TData;\n  warnings: string[];\n  errors: ToolError[];\n}\n\nexport interface CreateEnvelopeOptions<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  tool: string;\n  input?: TInput;\n  data?: TData;\n  warnings?: string[];\n  errors?: ToolError[];\n  rateLimit?: Partial<RateLimitMeta>;\n  schemaVersion?: string;\n}\n\nfunction buildRateLimitMeta(rateLimit: Partial<RateLimitMeta> = {}): RateLimitMeta {\n  return {\n    remaining: rateLimit.remaining ?? null,\n    resetAt: rateLimit.resetAt ?? null,\n    attempts: rateLimit.attempts ?? 1,\n    lastWaitMs: rateLimit.lastWaitMs ?? 0,\n  };\n}\n\nexport function createEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n>({\n  tool,\n  input = {} as TInput,\n  data = {} as TData,\n  warnings = [],\n  errors = [],\n  rateLimit,\n  schemaVersion,\n}: CreateEnvelopeOptions<TInput, TData>): ToolEnvelope<TInput, TData> {\n  return {\n    schemaVersion: schemaVersion ?? config.schemaVersion,\n    tool,\n    input,\n    meta: {\n      generatedAt: new Date().toISOString(),\n      source: config.source,\n      rateLimit: buildRateLimitMeta(rateLimit),\n    },\n    data,\n    warnings,\n    errors,\n  };\n}\n\n", "export const ERROR_EXIT_CODES = {\n  INPUT_INVALID: 1,\n  CONFIG_INVALID: 1,\n  FIGMA_AUTH: 1,\n  FIGMA_NOT_FOUND: 2,\n  FIGMA_RATE_LIMIT: 2,\n  NETWORK: 2,\n  INTERNAL: 3,\n} as const;\n\nexport type ErrorCode = keyof typeof ERROR_EXIT_CODES;\n\nexport interface ToolError<TDetail = unknown> {\n  code: ErrorCode | string;\n  message: string;\n  detail?: TDetail | null;\n}\n\nexport function createError<TDetail = unknown>(\n  code: ErrorCode | string,\n  message: string,\n  detail?: TDetail | null\n): ToolError<TDetail> {\n  return {\n    code,\n    message,\n    detail: detail ?? null,\n  };\n}\n\nexport function getExitCode(errors: ToolError[] = []): number {\n  if (!errors.length) {\n    return 0;\n  }\n\n  return errors.reduce((max, error) => {\n    const exitCode = ERROR_EXIT_CODES[error.code as ErrorCode] ?? 1;\n    return Math.max(max, exitCode);\n  }, 0);\n}\n\n", "import config from './config.ts';\nimport { createError } from './errors.ts';\nimport type { ToolError } from './errors.ts';\nimport type { RateLimitMeta } from './envelope.ts';\n\nconst BASE_URL = 'https://api.figma.com';\n\ntype SearchParams = Record<string, string | number | boolean | null | undefined>;\n\ninterface FigmaRequestOptions {\n  path: string;\n  method?: string;\n  token?: string;\n  headers?: Record<string, string>;\n  body?: unknown;\n  searchParams?: SearchParams;\n  maxAttempts?: number;\n  initialDelayMs?: number;\n}\n\ninterface FigmaSuccess<TData> {\n  ok: true;\n  data: TData;\n  rateLimit: RateLimitMeta;\n}\n\ninterface FigmaFailure {\n  ok: false;\n  error: ToolError<{ status?: number }>;\n  status?: number | null;\n  rateLimit: RateLimitMeta | null;\n}\n\nexport type FigmaResponse<TData> = FigmaSuccess<TData> | FigmaFailure;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction parseJsonSafely(text: string): unknown {\n  try {\n    return text ? JSON.parse(text) : {};\n  } catch {\n    return { raw: text };\n  }\n}\n\nfunction parseRateLimit(headers: Headers, attempts: number, lastWaitMs: number): RateLimitMeta {\n  const remainingHeader = headers.get('x-ratelimit-remaining');\n  const resetHeader = headers.get('x-ratelimit-reset');\n\n  let remaining: number | null = null;\n  if (remainingHeader !== null && remainingHeader !== undefined) {\n    const parsed = Number(remainingHeader);\n    remaining = Number.isNaN(parsed) ? null : parsed;\n  }\n\n  let resetAt: string | null = null;\n  if (resetHeader) {\n    const numericReset = Number(resetHeader);\n    if (!Number.isNaN(numericReset)) {\n      resetAt = new Date(numericReset * 1000).toISOString();\n    } else {\n      const date = new Date(resetHeader);\n      if (!Number.isNaN(date.valueOf())) {\n        resetAt = date.toISOString();\n      }\n    }\n  }\n\n  return {\n    remaining,\n    resetAt,\n    attempts,\n    lastWaitMs,\n  };\n}\n\nfunction computeBackoffMs(attempt: number, initialDelayMs: number): number {\n  return initialDelayMs * 2 ** (attempt - 1);\n}\n\nexport async function figmaRequest<TData = unknown>(\n  options: FigmaRequestOptions\n): Promise<FigmaResponse<TData>> {\n  const {\n    path,\n    method = 'GET',\n    token,\n    headers = {},\n    body,\n    searchParams,\n    maxAttempts = config.http?.maxAttempts ?? 5,\n    initialDelayMs = config.http?.initialDelayMs ?? 250,\n  } = options;\n\n  if (!token) {\n    return {\n      ok: false,\n      error: createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is missing from the environment.'),\n      status: null,\n      rateLimit: null,\n    };\n  }\n\n  const url = new URL(path, BASE_URL);\n\n  if (searchParams) {\n    Object.entries(searchParams).forEach(([key, value]) => {\n      if (value === undefined || value === null) return;\n      url.searchParams.append(key, String(value));\n    });\n  }\n\n  let attempt = 0;\n  let lastWaitMs = 0;\n\n  while (attempt < maxAttempts) {\n    attempt += 1;\n\n    const response = await fetch(url, {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        'X-Figma-Token': token,\n        ...headers,\n      },\n      body: body ? JSON.stringify(body) : undefined,\n    });\n\n    const text = await response.text();\n    const payload = parseJsonSafely(text) as { message?: string };\n    const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs);\n\n    if (response.ok) {\n      return { ok: true, data: payload as TData, rateLimit };\n    }\n\n    const status = response.status;\n\n    if (status === 401 || status === 403) {\n      return { ok: false, error: createError('FIGMA_AUTH', payload?.message ?? 'Figma token is unauthorized.', { status }), status, rateLimit };\n    }\n\n    if (status === 404) {\n      return { ok: false, error: createError('FIGMA_NOT_FOUND', payload?.message ?? 'Resource not found.', { status }), status, rateLimit };\n    }\n\n    if (status === 429 || status >= 500) {\n      if (attempt >= maxAttempts) {\n        return {\n          ok: false,\n          error: createError(status === 429 ? 'FIGMA_RATE_LIMIT' : 'NETWORK', payload?.message ?? 'Figma request failed after maximum retries.', { status }),\n          status,\n          rateLimit,\n        };\n      }\n\n      let waitMs = computeBackoffMs(attempt, initialDelayMs);\n      const resetHeader = response.headers.get('x-ratelimit-reset');\n      if (resetHeader) {\n        const asNumber = Number(resetHeader);\n        if (!Number.isNaN(asNumber)) {\n          const resetMs = asNumber * 1000;\n          const delta = resetMs - Date.now();\n          if (delta > 0) waitMs = Math.max(waitMs, delta);\n        }\n      }\n\n      const jitter = Math.floor(Math.random() * 100);\n      lastWaitMs = waitMs + jitter;\n      await sleep(lastWaitMs);\n      continue;\n    }\n\n    return { ok: false, error: createError('INTERNAL', payload?.message ?? 'Unexpected error from Figma API.', { status }), status, rateLimit };\n  }\n\n  return {\n    ok: false,\n    error: createError('NETWORK', 'Unable to reach Figma API.'),\n    status: null,\n    rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs },\n  };\n}\n\n"],
  "mappings": "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",
  "names": ["path", "envelope"]
}
 diff --git a/use-figma/scripts/get-design-context.mjs b/use-figma/scripts/get-design-context.mjs new file mode 100755 index 0000000..825361e --- /dev/null +++ b/use-figma/scripts/get-design-context.mjs @@ -0,0 +1,484 @@ +#!/usr/bin/env node + +// coding-tools/figma-tools/js/src/get-design-context.ts +import { createHash } from "node:crypto"; + +// coding-tools/figma-tools/js/src/_utils/cli-args.ts +function parseArgs(argv = process.argv.slice(2)) { + const args = { _: [] }; + for (let i = 0; i < argv.length; i += 1) { + const arg = argv[i]; + if (!arg.startsWith("-") || arg === "-") { + args._.push(arg); + continue; + } + if (arg === "--") { + const remaining = argv.slice(i + 1); + args._.push(...remaining); + break; + } + const [rawKey, inlineValue] = arg.split("=", 2); + const normalisedKey = rawKey.replace(/^-+/, ""); + let value; + if (inlineValue !== void 0) { + value = inlineValue; + } else { + const next = argv[i + 1]; + if (next !== void 0 && !next.startsWith("-")) { + value = next; + i += 1; + } else { + value = true; + } + } + args[normalisedKey] = value; + } + return args; +} + +// coding-tools/figma-tools/js/src/_utils/config.ts +var config_default = { + schemaVersion: "1.0.0", + source: "agentic-coding-templates/figma-tools", + http: { + maxAttempts: 5, + initialDelayMs: 250 + } +}; + +// coding-tools/figma-tools/js/src/_utils/envelope.ts +function buildRateLimitMeta(rateLimit = {}) { + return { + remaining: rateLimit.remaining ?? null, + resetAt: rateLimit.resetAt ?? null, + attempts: rateLimit.attempts ?? 1, + lastWaitMs: rateLimit.lastWaitMs ?? 0 + }; +} +function createEnvelope({ + tool, + input = {}, + data = {}, + warnings = [], + errors = [], + rateLimit, + schemaVersion +}) { + return { + schemaVersion: schemaVersion ?? config_default.schemaVersion, + tool, + input, + meta: { + generatedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: config_default.source, + rateLimit: buildRateLimitMeta(rateLimit) + }, + data, + warnings, + errors + }; +} + +// coding-tools/figma-tools/js/src/_utils/errors.ts +var ERROR_EXIT_CODES = { + INPUT_INVALID: 1, + CONFIG_INVALID: 1, + FIGMA_AUTH: 1, + FIGMA_NOT_FOUND: 2, + FIGMA_RATE_LIMIT: 2, + NETWORK: 2, + INTERNAL: 3 +}; +function createError(code, message, detail) { + return { + code, + message, + detail: detail ?? null + }; +} +function getExitCode(errors = []) { + if (!errors.length) { + return 0; + } + return errors.reduce((max, error) => { + const exitCode = ERROR_EXIT_CODES[error.code] ?? 1; + return Math.max(max, exitCode); + }, 0); +} + +// coding-tools/figma-tools/js/src/_utils/http-client.ts +var BASE_URL = "https://api.figma.com"; +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} +function parseJsonSafely(text) { + try { + return text ? JSON.parse(text) : {}; + } catch { + return { raw: text }; + } +} +function parseRateLimit(headers, attempts, lastWaitMs) { + const remainingHeader = headers.get("x-ratelimit-remaining"); + const resetHeader = headers.get("x-ratelimit-reset"); + let remaining = null; + if (remainingHeader !== null && remainingHeader !== void 0) { + const parsed = Number(remainingHeader); + remaining = Number.isNaN(parsed) ? null : parsed; + } + let resetAt = null; + if (resetHeader) { + const numericReset = Number(resetHeader); + if (!Number.isNaN(numericReset)) { + resetAt = new Date(numericReset * 1e3).toISOString(); + } else { + const date = new Date(resetHeader); + if (!Number.isNaN(date.valueOf())) { + resetAt = date.toISOString(); + } + } + } + return { + remaining, + resetAt, + attempts, + lastWaitMs + }; +} +function computeBackoffMs(attempt, initialDelayMs) { + return initialDelayMs * 2 ** (attempt - 1); +} +async function figmaRequest(options) { + const { + path, + method = "GET", + token, + headers = {}, + body, + searchParams, + maxAttempts = config_default.http?.maxAttempts ?? 5, + initialDelayMs = config_default.http?.initialDelayMs ?? 250 + } = options; + if (!token) { + return { + ok: false, + error: createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is missing from the environment."), + status: null, + rateLimit: null + }; + } + const url = new URL(path, BASE_URL); + if (searchParams) { + Object.entries(searchParams).forEach(([key, value]) => { + if (value === void 0 || value === null) return; + url.searchParams.append(key, String(value)); + }); + } + let attempt = 0; + let lastWaitMs = 0; + while (attempt < maxAttempts) { + attempt += 1; + const response = await fetch(url, { + method, + headers: { + "Content-Type": "application/json", + "X-Figma-Token": token, + ...headers + }, + body: body ? JSON.stringify(body) : void 0 + }); + const text = await response.text(); + const payload = parseJsonSafely(text); + const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs); + if (response.ok) { + return { ok: true, data: payload, rateLimit }; + } + const status = response.status; + if (status === 401 || status === 403) { + return { ok: false, error: createError("FIGMA_AUTH", payload?.message ?? "Figma token is unauthorized.", { status }), status, rateLimit }; + } + if (status === 404) { + return { ok: false, error: createError("FIGMA_NOT_FOUND", payload?.message ?? "Resource not found.", { status }), status, rateLimit }; + } + if (status === 429 || status >= 500) { + if (attempt >= maxAttempts) { + return { + ok: false, + error: createError(status === 429 ? "FIGMA_RATE_LIMIT" : "NETWORK", payload?.message ?? "Figma request failed after maximum retries.", { status }), + status, + rateLimit + }; + } + let waitMs = computeBackoffMs(attempt, initialDelayMs); + const resetHeader = response.headers.get("x-ratelimit-reset"); + if (resetHeader) { + const asNumber = Number(resetHeader); + if (!Number.isNaN(asNumber)) { + const resetMs = asNumber * 1e3; + const delta = resetMs - Date.now(); + if (delta > 0) waitMs = Math.max(waitMs, delta); + } + } + const jitter = Math.floor(Math.random() * 100); + lastWaitMs = waitMs + jitter; + await sleep(lastWaitMs); + continue; + } + return { ok: false, error: createError("INTERNAL", payload?.message ?? "Unexpected error from Figma API.", { status }), status, rateLimit }; + } + return { + ok: false, + error: createError("NETWORK", "Unable to reach Figma API."), + status: null, + rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs } + }; +} + +// coding-tools/figma-tools/js/src/_utils/url-parse.ts +var FILE_KEY_REGEX = /figma\.com\/(?:file|design)\/([A-Za-z0-9]+)\//i; +function parseFigmaUrl(input) { + if (!input) return { fileKey: null, nodeId: null }; + try { + const url = new URL(input); + const match = url.href.match(FILE_KEY_REGEX); + const fileKey = match ? match[1] : null; + const nodeParam = url.searchParams.get("node-id"); + const nodeId = nodeParam ? ensureNodeId(nodeParam) : null; + return { fileKey, nodeId }; + } catch { + return { fileKey: null, nodeId: null }; + } +} +function ensureNodeId(value) { + if (!value) return null; + const decoded = decodeURIComponent(value); + if (decoded.includes(":")) return decoded; + if (/^[0-9]+-[0-9]+$/.test(decoded)) { + const [left, right] = decoded.split("-", 2); + return `${left}:${right}`; + } + return decoded; +} + +// coding-tools/figma-tools/js/src/get-design-context.ts +var TOOL_NAME = "get-design-context"; +var VALID_IMAGE_FORMATS = ["png", "jpg", "jpeg", "svg"]; +function log(message, verbose) { + if (verbose) { + process.stderr.write(`[${TOOL_NAME}] ${message} +`); + } +} +function toOptionalString(value) { + return typeof value === "string" && value.length > 0 ? value : null; +} +function exitWithEnvelope(envelope, errors = []) { + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +function mapLayoutNode(node) { + const children = Array.isArray(node.children) ? node.children.map(mapLayoutNode) : []; + const bbox = node.absoluteBoundingBox; + const layout = bbox ? { x: bbox.x ?? 0, y: bbox.y ?? 0, width: bbox.width ?? 0, height: bbox.height ?? 0 } : null; + return { + id: node.id, + name: node.name, + type: node.type, + visible: node.visible ?? true, + layout, + rotation: node.rotation ?? 0, + clipsContent: node.clipsContent ?? false, + characters: node.characters ?? null, + fills: node.fills ?? [], + strokes: node.strokes ?? [], + effects: node.effects ?? [], + tailwindSuggestion: null, + children + }; +} +function buildStyleTokens(node) { + const cornerRadius = Array.isArray(node.rectangleCornerRadii) && node.rectangleCornerRadii.length > 0 ? node.rectangleCornerRadii : node.cornerRadius ?? null; + return { + fills: node.fills ?? [], + strokes: node.strokes ?? [], + effects: node.effects ?? [], + backgroundColor: node.backgroundColor ?? null, + textStyle: node.style ?? null, + styles: node.styles ?? {}, + cornerRadius + }; +} +function buildSelectionSummary(node, components, componentSets) { + const componentId = node.componentId ?? null; + const componentSetId = node.componentSetId ?? null; + const componentMeta = componentId ? components[componentId] ?? null : null; + const componentSetMeta = componentSetId ? componentSets[componentSetId] ?? null : null; + return { + id: node.id, + name: node.name, + type: node.type, + componentId, + componentKey: componentMeta?.key ?? null, + componentName: componentMeta?.name ?? null, + componentSetId, + componentSetName: componentSetMeta?.name ?? null, + variantProperties: node.variantProperties ?? null + }; +} +function computeLayoutHash(layoutTree) { + const json = JSON.stringify(layoutTree); + return createHash("sha1").update(json).digest("hex"); +} +async function fetchPreviewImage(fileKey, nodeId, token, imageFormat, scale, warnings, verbose) { + const format = VALID_IMAGE_FORMATS.includes(imageFormat) ? imageFormat : "png"; + const scaleClamped = Number.isFinite(scale) && scale > 0 ? scale : 1; + log(`Requesting preview image format=${format}, scale=${scaleClamped}`, verbose); + const imageResponse = await figmaRequest({ + path: `/v1/images/${fileKey}`, + token, + searchParams: { ids: nodeId, format, scale: scaleClamped } + }); + if (!imageResponse.ok) { + warnings.push(imageResponse.error?.message ?? "Failed to request preview image."); + return null; + } + const url = imageResponse.data?.images?.[nodeId]; + if (!url) return null; + return { url, format, size: `${scaleClamped}x` }; +} +async function main() { + const args = parseArgs(); + const verbose = Boolean(args.verbose ?? args.v); + const schemaVersion = toOptionalString(args["schema-version"]) ?? void 0; + const warnings = []; + const errors = []; + const token = process.env.FIGMA_ACCESS_TOKEN; + if (!token || !token.trim()) { + errors.push(createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is required but was not provided.")); + const envelope2 = createEnvelope({ + tool: TOOL_NAME, + input: { fileKey: null, nodeId: null, includeImages: false, imageFormat: "png", scale: 1 }, + warnings, + errors, + schemaVersion, + data: {} + }); + exitWithEnvelope(envelope2, errors); + } + const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u); + let fileKey = toOptionalString(args["file-key"]) ?? void 0; + let nodeId = ensureNodeId(toOptionalString(args["node-id"])); + if (urlInput) { + const parsed = parseFigmaUrl(urlInput); + fileKey = fileKey || parsed.fileKey || void 0; + nodeId = nodeId || parsed.nodeId; + } + const includeImages = args["include-images"] !== "false"; + const imageFormatInput = String(args["image-format"] ?? "png").toLowerCase(); + const imageFormat = VALID_IMAGE_FORMATS.includes(imageFormatInput) ? imageFormatInput : "png"; + const scaleInput = Number(args.scale ?? 1); + const imageScale = Number.isFinite(scaleInput) && scaleInput > 0 ? scaleInput : 1; + const input = { + fileKey: fileKey ?? null, + nodeId: nodeId ?? null, + includeImages, + imageFormat, + scale: imageScale + }; + if (!fileKey) { + errors.push(createError("INPUT_INVALID", "A valid Figma file key is required (--file-key or --url).")); + } + if (!nodeId) { + errors.push(createError("INPUT_INVALID", "A valid Figma node id is required (--node-id or --url with node-id).")); + } + if (errors.length) { + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + const resolvedFileKey = fileKey; + const resolvedNodeId = nodeId; + log(`Fetching node ${resolvedNodeId} from file ${resolvedFileKey}`, verbose); + const nodeResponse = await figmaRequest({ + path: `/v1/files/${resolvedFileKey}/nodes`, + token, + searchParams: { ids: resolvedNodeId } + }); + if (!nodeResponse.ok) { + errors.push(nodeResponse.error ?? createError("INTERNAL", "Failed to fetch node data.")); + const envelope2 = createEnvelope({ + tool: TOOL_NAME, + input, + warnings, + errors, + rateLimit: nodeResponse.rateLimit ?? void 0, + data: {}, + schemaVersion + }); + exitWithEnvelope(envelope2, errors); + } + const nodePayload = nodeResponse.data ?? {}; + const nodesMap = nodePayload.nodes ?? {}; + const nodeWrapper = nodesMap[resolvedNodeId]; + if (!nodeWrapper || !nodeWrapper.document) { + errors.push(createError("FIGMA_NOT_FOUND", `Node ${resolvedNodeId} was not found in file ${resolvedFileKey}.`)); + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, rateLimit: nodeResponse.rateLimit ?? void 0, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + const node = nodeWrapper.document; + const components = nodeWrapper.components ?? {}; + const componentSets = nodeWrapper.componentSets ?? {}; + const selectionSummary = buildSelectionSummary(node, components, componentSets); + const layoutTree = mapLayoutNode(node); + const styleTokens = buildStyleTokens(node); + const layoutHash = computeLayoutHash(layoutTree); + let preview = null; + if (includeImages) { + preview = await fetchPreviewImage( + resolvedFileKey, + resolvedNodeId, + token, + imageFormat, + imageScale, + warnings, + verbose + ); + } + const data = { + file: { + key: resolvedFileKey, + name: nodePayload?.name ?? null, + lastModified: nodePayload?.lastModified ?? null + }, + selectionSummary, + layoutTree, + styleTokens, + layoutHash, + images: preview ? { preview } : null + }; + const envelope = createEnvelope({ + tool: TOOL_NAME, + input, + data, + warnings, + errors, + rateLimit: nodeResponse.rateLimit ?? void 0, + schemaVersion + }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +main().catch((error) => { + const message = error instanceof Error ? error.message : "Unknown error"; + const envelope = createEnvelope({ + tool: TOOL_NAME, + input: { fileKey: null, nodeId: null, includeImages: false, imageFormat: "png", scale: 1 }, + errors: [createError("INTERNAL", message, { stack: error instanceof Error ? error.stack : void 0 })], + data: {} + }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(3); +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/get-design-context.ts", "../src/_utils/cli-args.ts", "../src/_utils/config.ts", "../src/_utils/envelope.ts", "../src/_utils/errors.ts", "../src/_utils/http-client.ts", "../src/_utils/url-parse.ts"],
  "sourcesContent": ["#!/usr/bin/env node\n\nimport { createHash } from 'node:crypto'\nimport { parseArgs, type CliArgs } from './_utils/cli-args.ts'\nimport { createEnvelope, type ToolEnvelope } from './_utils/envelope.ts'\nimport { createError, getExitCode, type ToolError } from './_utils/errors.ts'\nimport { figmaRequest } from './_utils/http-client.ts'\nimport { parseFigmaUrl, ensureNodeId } from './_utils/url-parse.ts'\n\nconst TOOL_NAME = 'get-design-context'\nconst VALID_IMAGE_FORMATS = ['png', 'jpg', 'jpeg', 'svg']\n\ntype EmptyData = Record<string, never>\n\ninterface ToolInput extends Record<string, unknown> {\n  fileKey: string | null\n  nodeId: string | null\n  includeImages: boolean\n  imageFormat: string\n  scale: number\n}\n\ninterface DesignContextData {\n  file: {\n    key: string\n    name: string | null\n    lastModified: string | null\n  }\n  selectionSummary: SelectionSummary\n  layoutTree: LayoutNode\n  styleTokens: StyleTokens\n  layoutHash: string | null\n  images: { preview: PreviewImage } | null\n}\n\ninterface FigmaComponentMeta {\n  key?: string\n  name?: string\n  description?: string\n}\n\ninterface FigmaComponentSetMeta {\n  name?: string\n  componentSetProperties?: Record<string, unknown>\n}\n\ninterface FigmaNode {\n  id: string\n  name?: string\n  type?: string\n  componentId?: string\n  componentSetId?: string\n  variantProperties?: Record<string, unknown>\n  absoluteBoundingBox?: { x?: number; y?: number; width?: number; height?: number }\n  children?: FigmaNode[]\n  visible?: boolean\n  rotation?: number\n  clipsContent?: boolean\n  characters?: string\n  fills?: unknown[]\n  strokes?: unknown[]\n  effects?: unknown[]\n  style?: Record<string, unknown>\n  styles?: Record<string, unknown>\n  backgroundColor?: Record<string, unknown>\n  cornerRadius?: number\n  rectangleCornerRadii?: number[]\n}\n\ninterface NodeWrapper {\n  document?: FigmaNode\n  components?: Record<string, FigmaComponentMeta>\n  componentSets?: Record<string, FigmaComponentSetMeta>\n}\n\ninterface NodesResponse {\n  name?: string\n  lastModified?: string\n  nodes?: Record<string, NodeWrapper>\n}\n\ninterface ImageResponse {\n  images?: Record<string, string>\n}\n\ninterface SelectionSummary {\n  id: string\n  name?: string\n  type?: string\n  componentId?: string | null\n  componentKey?: string | null\n  componentName?: string | null\n  componentSetId?: string | null\n  componentSetName?: string | null\n  variantProperties?: Record<string, unknown> | null\n}\n\ninterface LayoutNode {\n  id: string\n  name?: string\n  type?: string\n  visible: boolean\n  layout: { x: number; y: number; width: number; height: number } | null\n  rotation: number\n  clipsContent: boolean\n  characters: string | null\n  fills: unknown[]\n  strokes: unknown[]\n  effects: unknown[]\n  tailwindSuggestion: null\n  children: LayoutNode[]\n}\n\ninterface StyleTokens {\n  fills: unknown[]\n  strokes: unknown[]\n  effects: unknown[]\n  backgroundColor: Record<string, unknown> | null\n  textStyle: Record<string, unknown> | null\n  styles: Record<string, unknown>\n  cornerRadius: number | number[] | null\n}\n\ninterface PreviewImage {\n  url: string\n  format: string\n  size: string\n}\n\nfunction log(message: string, verbose: boolean): void {\n  if (verbose) {\n    process.stderr.write(`[${TOOL_NAME}] ${message}\\n`)\n  }\n}\n\nfunction toOptionalString(value: CliArgs[string]): string | null {\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nfunction exitWithEnvelope(\n  envelope: ToolEnvelope<ToolInput, DesignContextData | EmptyData>,\n  errors: ToolError[] = []\n): never {\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nfunction mapLayoutNode(node: FigmaNode): LayoutNode {\n  const children = Array.isArray(node.children) ? node.children.map(mapLayoutNode) : []\n  const bbox = node.absoluteBoundingBox\n  const layout = bbox\n    ? { x: bbox.x ?? 0, y: bbox.y ?? 0, width: bbox.width ?? 0, height: bbox.height ?? 0 }\n    : null\n\n  return {\n    id: node.id,\n    name: node.name,\n    type: node.type,\n    visible: node.visible ?? true,\n    layout,\n    rotation: node.rotation ?? 0,\n    clipsContent: node.clipsContent ?? false,\n    characters: node.characters ?? null,\n    fills: node.fills ?? [],\n    strokes: node.strokes ?? [],\n    effects: node.effects ?? [],\n    tailwindSuggestion: null,\n    children,\n  }\n}\n\nfunction buildStyleTokens(node: FigmaNode): StyleTokens {\n  const cornerRadius: number | number[] | null =\n    (Array.isArray(node.rectangleCornerRadii) && node.rectangleCornerRadii.length > 0)\n      ? node.rectangleCornerRadii\n      : (node.cornerRadius ?? null)\n\n  return {\n    fills: node.fills ?? [],\n    strokes: node.strokes ?? [],\n    effects: node.effects ?? [],\n    backgroundColor: node.backgroundColor ?? null,\n    textStyle: node.style ?? null,\n    styles: node.styles ?? {},\n    cornerRadius,\n  }\n}\n\nfunction buildSelectionSummary(\n  node: FigmaNode,\n  components: Record<string, FigmaComponentMeta>,\n  componentSets: Record<string, FigmaComponentSetMeta>\n): SelectionSummary {\n  const componentId = node.componentId ?? null\n  const componentSetId = node.componentSetId ?? null\n  const componentMeta = componentId ? components[componentId] ?? null : null\n  const componentSetMeta = componentSetId ? componentSets[componentSetId] ?? null : null\n\n  return {\n    id: node.id,\n    name: node.name,\n    type: node.type,\n    componentId,\n    componentKey: componentMeta?.key ?? null,\n    componentName: componentMeta?.name ?? null,\n    componentSetId,\n    componentSetName: componentSetMeta?.name ?? null,\n    variantProperties: node.variantProperties ?? null,\n  }\n}\n\nfunction computeLayoutHash(layoutTree: LayoutNode): string {\n  const json = JSON.stringify(layoutTree)\n  return createHash('sha1').update(json).digest('hex')\n}\n\nasync function fetchPreviewImage(\n  fileKey: string,\n  nodeId: string,\n  token: string,\n  imageFormat: string,\n  scale: number,\n  warnings: string[],\n  verbose: boolean\n): Promise<PreviewImage | null> {\n  const format = VALID_IMAGE_FORMATS.includes(imageFormat) ? imageFormat : 'png'\n  const scaleClamped = Number.isFinite(scale) && scale > 0 ? scale : 1\n\n  log(`Requesting preview image format=${format}, scale=${scaleClamped}`, verbose)\n  const imageResponse = await figmaRequest<ImageResponse>({\n    path: `/v1/images/${fileKey}`,\n    token,\n    searchParams: { ids: nodeId, format, scale: scaleClamped },\n  })\n\n  if (!imageResponse.ok) {\n    warnings.push(imageResponse.error?.message ?? 'Failed to request preview image.')\n    return null\n  }\n\n  const url = imageResponse.data?.images?.[nodeId]\n  if (!url) return null\n  return { url, format, size: `${scaleClamped}x` }\n}\n\nasync function main(): Promise<void> {\n  const args = parseArgs()\n  const verbose = Boolean(args.verbose ?? args.v)\n  const schemaVersion = toOptionalString(args['schema-version']) ?? undefined\n\n  const warnings: string[] = []\n  const errors: ToolError[] = []\n\n  const token = process.env.FIGMA_ACCESS_TOKEN\n  if (!token || !token.trim()) {\n    errors.push(createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is required but was not provided.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({\n      tool: TOOL_NAME,\n      input: { fileKey: null, nodeId: null, includeImages: false, imageFormat: 'png', scale: 1 },\n      warnings,\n      errors,\n      schemaVersion,\n      data: {} as EmptyData,\n    })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u)\n  let fileKey = toOptionalString(args['file-key']) ?? undefined\n  let nodeId = ensureNodeId(toOptionalString(args['node-id']))\n\n  if (urlInput) {\n    const parsed = parseFigmaUrl(urlInput)\n    fileKey = fileKey || parsed.fileKey || undefined\n    nodeId = nodeId || parsed.nodeId\n  }\n\n  const includeImages = args['include-images'] !== 'false'\n  const imageFormatInput = String(args['image-format'] ?? 'png').toLowerCase()\n  const imageFormat = VALID_IMAGE_FORMATS.includes(imageFormatInput) ? imageFormatInput : 'png'\n\n  const scaleInput = Number(args.scale ?? 1)\n  const imageScale = Number.isFinite(scaleInput) && scaleInput > 0 ? scaleInput : 1\n\n  const input: ToolInput = {\n    fileKey: fileKey ?? null,\n    nodeId: nodeId ?? null,\n    includeImages,\n    imageFormat,\n    scale: imageScale,\n  }\n\n  if (!fileKey) {\n    errors.push(createError('INPUT_INVALID', 'A valid Figma file key is required (--file-key or --url).'))\n  }\n  if (!nodeId) {\n    errors.push(createError('INPUT_INVALID', 'A valid Figma node id is required (--node-id or --url with node-id).'))\n  }\n  if (errors.length) {\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, data: {} as EmptyData, schemaVersion })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const resolvedFileKey = fileKey as string\n  const resolvedNodeId = nodeId as string\n\n  log(`Fetching node ${resolvedNodeId} from file ${resolvedFileKey}`, verbose)\n  const nodeResponse = await figmaRequest<NodesResponse>({\n    path: `/v1/files/${resolvedFileKey}/nodes`,\n    token,\n    searchParams: { ids: resolvedNodeId },\n  })\n\n  if (!nodeResponse.ok) {\n    errors.push(nodeResponse.error ?? createError('INTERNAL', 'Failed to fetch node data.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({\n      tool: TOOL_NAME,\n      input,\n      warnings,\n      errors,\n      rateLimit: nodeResponse.rateLimit ?? undefined,\n      data: {} as EmptyData,\n      schemaVersion,\n    })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const nodePayload = nodeResponse.data ?? {}\n  const nodesMap = nodePayload.nodes ?? {}\n  const nodeWrapper = nodesMap[resolvedNodeId]\n  if (!nodeWrapper || !nodeWrapper.document) {\n    errors.push(createError('FIGMA_NOT_FOUND', `Node ${resolvedNodeId} was not found in file ${resolvedFileKey}.`))\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, rateLimit: nodeResponse.rateLimit ?? undefined, data: {} as EmptyData, schemaVersion })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const node = nodeWrapper.document\n  const components = nodeWrapper.components ?? {}\n  const componentSets = nodeWrapper.componentSets ?? {}\n\n  const selectionSummary = buildSelectionSummary(node, components, componentSets)\n  const layoutTree = mapLayoutNode(node)\n  const styleTokens = buildStyleTokens(node)\n  const layoutHash = computeLayoutHash(layoutTree)\n\n  let preview: PreviewImage | null = null\n  if (includeImages) {\n    preview = await fetchPreviewImage(\n      resolvedFileKey,\n      resolvedNodeId,\n      token,\n      imageFormat,\n      imageScale,\n      warnings,\n      verbose\n    )\n  }\n\n  const data = {\n    file: {\n      key: resolvedFileKey,\n      name: nodePayload?.name ?? null,\n      lastModified: nodePayload?.lastModified ?? null,\n    },\n    selectionSummary,\n    layoutTree,\n    styleTokens,\n    layoutHash,\n    images: preview ? { preview } : null,\n  }\n\n  const envelope = createEnvelope<ToolInput, DesignContextData>({\n    tool: TOOL_NAME,\n    input,\n    data,\n    warnings,\n    errors,\n    rateLimit: nodeResponse.rateLimit ?? undefined,\n    schemaVersion,\n  })\n\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nmain().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : 'Unknown error'\n  const envelope = createEnvelope<ToolInput, EmptyData>({\n    tool: TOOL_NAME,\n    input: { fileKey: null, nodeId: null, includeImages: false, imageFormat: 'png', scale: 1 },\n    errors: [createError('INTERNAL', message, { stack: error instanceof Error ? error.stack : undefined })],\n    data: {} as EmptyData,\n  })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(3)\n})\n\n", "export type CliArgValue = string | boolean;\n\nexport interface CliArgs {\n  _: string[];\n  [key: string]: CliArgValue | string[];\n}\n\nexport function parseArgs(argv: string[] = process.argv.slice(2)): CliArgs {\n  const args: CliArgs = { _: [] };\n\n  for (let i = 0; i < argv.length; i += 1) {\n    const arg = argv[i];\n\n    if (!arg.startsWith('-') || arg === '-') {\n      args._.push(arg);\n      continue;\n    }\n\n    if (arg === '--') {\n      const remaining = argv.slice(i + 1);\n      args._.push(...remaining);\n      break;\n    }\n\n    const [rawKey, inlineValue] = arg.split('=', 2);\n    const normalisedKey = rawKey.replace(/^-+/, '');\n\n    let value: CliArgValue;\n    if (inlineValue !== undefined) {\n      value = inlineValue;\n    } else {\n      const next = argv[i + 1];\n      if (next !== undefined && !next.startsWith('-')) {\n        value = next;\n        i += 1;\n      } else {\n        value = true;\n      }\n    }\n\n    args[normalisedKey] = value;\n  }\n\n  return args;\n}\n\n", "export default {\n  schemaVersion: '1.0.0',\n  source: 'agentic-coding-templates/figma-tools',\n  http: {\n    maxAttempts: 5,\n    initialDelayMs: 250,\n  },\n} as const;\n\n", "import config from './config.ts';\nimport type { ToolError } from './errors.ts';\n\nexport interface RateLimitMeta {\n  remaining: number | null;\n  resetAt: string | null;\n  attempts: number;\n  lastWaitMs: number;\n}\n\nexport interface ToolEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  schemaVersion: string;\n  tool: string;\n  input: TInput;\n  meta: {\n    generatedAt: string;\n    source: string;\n    rateLimit: RateLimitMeta;\n  };\n  data: TData;\n  warnings: string[];\n  errors: ToolError[];\n}\n\nexport interface CreateEnvelopeOptions<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  tool: string;\n  input?: TInput;\n  data?: TData;\n  warnings?: string[];\n  errors?: ToolError[];\n  rateLimit?: Partial<RateLimitMeta>;\n  schemaVersion?: string;\n}\n\nfunction buildRateLimitMeta(rateLimit: Partial<RateLimitMeta> = {}): RateLimitMeta {\n  return {\n    remaining: rateLimit.remaining ?? null,\n    resetAt: rateLimit.resetAt ?? null,\n    attempts: rateLimit.attempts ?? 1,\n    lastWaitMs: rateLimit.lastWaitMs ?? 0,\n  };\n}\n\nexport function createEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n>({\n  tool,\n  input = {} as TInput,\n  data = {} as TData,\n  warnings = [],\n  errors = [],\n  rateLimit,\n  schemaVersion,\n}: CreateEnvelopeOptions<TInput, TData>): ToolEnvelope<TInput, TData> {\n  return {\n    schemaVersion: schemaVersion ?? config.schemaVersion,\n    tool,\n    input,\n    meta: {\n      generatedAt: new Date().toISOString(),\n      source: config.source,\n      rateLimit: buildRateLimitMeta(rateLimit),\n    },\n    data,\n    warnings,\n    errors,\n  };\n}\n\n", "export const ERROR_EXIT_CODES = {\n  INPUT_INVALID: 1,\n  CONFIG_INVALID: 1,\n  FIGMA_AUTH: 1,\n  FIGMA_NOT_FOUND: 2,\n  FIGMA_RATE_LIMIT: 2,\n  NETWORK: 2,\n  INTERNAL: 3,\n} as const;\n\nexport type ErrorCode = keyof typeof ERROR_EXIT_CODES;\n\nexport interface ToolError<TDetail = unknown> {\n  code: ErrorCode | string;\n  message: string;\n  detail?: TDetail | null;\n}\n\nexport function createError<TDetail = unknown>(\n  code: ErrorCode | string,\n  message: string,\n  detail?: TDetail | null\n): ToolError<TDetail> {\n  return {\n    code,\n    message,\n    detail: detail ?? null,\n  };\n}\n\nexport function getExitCode(errors: ToolError[] = []): number {\n  if (!errors.length) {\n    return 0;\n  }\n\n  return errors.reduce((max, error) => {\n    const exitCode = ERROR_EXIT_CODES[error.code as ErrorCode] ?? 1;\n    return Math.max(max, exitCode);\n  }, 0);\n}\n\n", "import config from './config.ts';\nimport { createError } from './errors.ts';\nimport type { ToolError } from './errors.ts';\nimport type { RateLimitMeta } from './envelope.ts';\n\nconst BASE_URL = 'https://api.figma.com';\n\ntype SearchParams = Record<string, string | number | boolean | null | undefined>;\n\ninterface FigmaRequestOptions {\n  path: string;\n  method?: string;\n  token?: string;\n  headers?: Record<string, string>;\n  body?: unknown;\n  searchParams?: SearchParams;\n  maxAttempts?: number;\n  initialDelayMs?: number;\n}\n\ninterface FigmaSuccess<TData> {\n  ok: true;\n  data: TData;\n  rateLimit: RateLimitMeta;\n}\n\ninterface FigmaFailure {\n  ok: false;\n  error: ToolError<{ status?: number }>;\n  status?: number | null;\n  rateLimit: RateLimitMeta | null;\n}\n\nexport type FigmaResponse<TData> = FigmaSuccess<TData> | FigmaFailure;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction parseJsonSafely(text: string): unknown {\n  try {\n    return text ? JSON.parse(text) : {};\n  } catch {\n    return { raw: text };\n  }\n}\n\nfunction parseRateLimit(headers: Headers, attempts: number, lastWaitMs: number): RateLimitMeta {\n  const remainingHeader = headers.get('x-ratelimit-remaining');\n  const resetHeader = headers.get('x-ratelimit-reset');\n\n  let remaining: number | null = null;\n  if (remainingHeader !== null && remainingHeader !== undefined) {\n    const parsed = Number(remainingHeader);\n    remaining = Number.isNaN(parsed) ? null : parsed;\n  }\n\n  let resetAt: string | null = null;\n  if (resetHeader) {\n    const numericReset = Number(resetHeader);\n    if (!Number.isNaN(numericReset)) {\n      resetAt = new Date(numericReset * 1000).toISOString();\n    } else {\n      const date = new Date(resetHeader);\n      if (!Number.isNaN(date.valueOf())) {\n        resetAt = date.toISOString();\n      }\n    }\n  }\n\n  return {\n    remaining,\n    resetAt,\n    attempts,\n    lastWaitMs,\n  };\n}\n\nfunction computeBackoffMs(attempt: number, initialDelayMs: number): number {\n  return initialDelayMs * 2 ** (attempt - 1);\n}\n\nexport async function figmaRequest<TData = unknown>(\n  options: FigmaRequestOptions\n): Promise<FigmaResponse<TData>> {\n  const {\n    path,\n    method = 'GET',\n    token,\n    headers = {},\n    body,\n    searchParams,\n    maxAttempts = config.http?.maxAttempts ?? 5,\n    initialDelayMs = config.http?.initialDelayMs ?? 250,\n  } = options;\n\n  if (!token) {\n    return {\n      ok: false,\n      error: createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is missing from the environment.'),\n      status: null,\n      rateLimit: null,\n    };\n  }\n\n  const url = new URL(path, BASE_URL);\n\n  if (searchParams) {\n    Object.entries(searchParams).forEach(([key, value]) => {\n      if (value === undefined || value === null) return;\n      url.searchParams.append(key, String(value));\n    });\n  }\n\n  let attempt = 0;\n  let lastWaitMs = 0;\n\n  while (attempt < maxAttempts) {\n    attempt += 1;\n\n    const response = await fetch(url, {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        'X-Figma-Token': token,\n        ...headers,\n      },\n      body: body ? JSON.stringify(body) : undefined,\n    });\n\n    const text = await response.text();\n    const payload = parseJsonSafely(text) as { message?: string };\n    const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs);\n\n    if (response.ok) {\n      return { ok: true, data: payload as TData, rateLimit };\n    }\n\n    const status = response.status;\n\n    if (status === 401 || status === 403) {\n      return { ok: false, error: createError('FIGMA_AUTH', payload?.message ?? 'Figma token is unauthorized.', { status }), status, rateLimit };\n    }\n\n    if (status === 404) {\n      return { ok: false, error: createError('FIGMA_NOT_FOUND', payload?.message ?? 'Resource not found.', { status }), status, rateLimit };\n    }\n\n    if (status === 429 || status >= 500) {\n      if (attempt >= maxAttempts) {\n        return {\n          ok: false,\n          error: createError(status === 429 ? 'FIGMA_RATE_LIMIT' : 'NETWORK', payload?.message ?? 'Figma request failed after maximum retries.', { status }),\n          status,\n          rateLimit,\n        };\n      }\n\n      let waitMs = computeBackoffMs(attempt, initialDelayMs);\n      const resetHeader = response.headers.get('x-ratelimit-reset');\n      if (resetHeader) {\n        const asNumber = Number(resetHeader);\n        if (!Number.isNaN(asNumber)) {\n          const resetMs = asNumber * 1000;\n          const delta = resetMs - Date.now();\n          if (delta > 0) waitMs = Math.max(waitMs, delta);\n        }\n      }\n\n      const jitter = Math.floor(Math.random() * 100);\n      lastWaitMs = waitMs + jitter;\n      await sleep(lastWaitMs);\n      continue;\n    }\n\n    return { ok: false, error: createError('INTERNAL', payload?.message ?? 'Unexpected error from Figma API.', { status }), status, rateLimit };\n  }\n\n  return {\n    ok: false,\n    error: createError('NETWORK', 'Unable to reach Figma API.'),\n    status: null,\n    rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs },\n  };\n}\n\n", "const FILE_KEY_REGEX = /figma\\.com\\/(?:file|design)\\/([A-Za-z0-9]+)\\//i;\n\nexport interface ParsedFigmaUrl {\n  fileKey: string | null;\n  nodeId: string | null;\n}\n\nexport function parseFigmaUrl(input: string | null | undefined): ParsedFigmaUrl {\n  if (!input) return { fileKey: null, nodeId: null };\n  try {\n    const url = new URL(input);\n    const match = url.href.match(FILE_KEY_REGEX);\n    const fileKey = match ? match[1] : null;\n    const nodeParam = url.searchParams.get('node-id');\n    const nodeId = nodeParam ? ensureNodeId(nodeParam) : null;\n    return { fileKey, nodeId };\n  } catch {\n    return { fileKey: null, nodeId: null };\n  }\n}\n\nexport function ensureNodeId(value: string | null | undefined): string | null {\n  if (!value) return null;\n  const decoded = decodeURIComponent(value);\n  if (decoded.includes(':')) return decoded;\n  if (/^[0-9]+-[0-9]+$/.test(decoded)) {\n    const [left, right] = decoded.split('-', 2);\n    return `${left}:${right}`;\n  }\n  return decoded;\n}\n\n"],
  "mappings": "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",
  "names": ["envelope"]
}
 diff --git a/use-figma/scripts/get-metadata.mjs b/use-figma/scripts/get-metadata.mjs new file mode 100755 index 0000000..32da120 --- /dev/null +++ b/use-figma/scripts/get-metadata.mjs @@ -0,0 +1,469 @@ +#!/usr/bin/env node + +// coding-tools/figma-tools/js/src/_utils/cli-args.ts +function parseArgs(argv = process.argv.slice(2)) { + const args = { _: [] }; + for (let i = 0; i < argv.length; i += 1) { + const arg = argv[i]; + if (!arg.startsWith("-") || arg === "-") { + args._.push(arg); + continue; + } + if (arg === "--") { + const remaining = argv.slice(i + 1); + args._.push(...remaining); + break; + } + const [rawKey, inlineValue] = arg.split("=", 2); + const normalisedKey = rawKey.replace(/^-+/, ""); + let value; + if (inlineValue !== void 0) { + value = inlineValue; + } else { + const next = argv[i + 1]; + if (next !== void 0 && !next.startsWith("-")) { + value = next; + i += 1; + } else { + value = true; + } + } + args[normalisedKey] = value; + } + return args; +} + +// coding-tools/figma-tools/js/src/_utils/url-parse.ts +var FILE_KEY_REGEX = /figma\.com\/(?:file|design)\/([A-Za-z0-9]+)\//i; +function parseFigmaUrl(input) { + if (!input) return { fileKey: null, nodeId: null }; + try { + const url = new URL(input); + const match = url.href.match(FILE_KEY_REGEX); + const fileKey = match ? match[1] : null; + const nodeParam = url.searchParams.get("node-id"); + const nodeId = nodeParam ? ensureNodeId(nodeParam) : null; + return { fileKey, nodeId }; + } catch { + return { fileKey: null, nodeId: null }; + } +} +function ensureNodeId(value) { + if (!value) return null; + const decoded = decodeURIComponent(value); + if (decoded.includes(":")) return decoded; + if (/^[0-9]+-[0-9]+$/.test(decoded)) { + const [left, right] = decoded.split("-", 2); + return `${left}:${right}`; + } + return decoded; +} + +// coding-tools/figma-tools/js/src/_utils/config.ts +var config_default = { + schemaVersion: "1.0.0", + source: "agentic-coding-templates/figma-tools", + http: { + maxAttempts: 5, + initialDelayMs: 250 + } +}; + +// coding-tools/figma-tools/js/src/_utils/envelope.ts +function buildRateLimitMeta(rateLimit = {}) { + return { + remaining: rateLimit.remaining ?? null, + resetAt: rateLimit.resetAt ?? null, + attempts: rateLimit.attempts ?? 1, + lastWaitMs: rateLimit.lastWaitMs ?? 0 + }; +} +function createEnvelope({ + tool, + input = {}, + data = {}, + warnings = [], + errors = [], + rateLimit, + schemaVersion +}) { + return { + schemaVersion: schemaVersion ?? config_default.schemaVersion, + tool, + input, + meta: { + generatedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: config_default.source, + rateLimit: buildRateLimitMeta(rateLimit) + }, + data, + warnings, + errors + }; +} + +// coding-tools/figma-tools/js/src/_utils/errors.ts +var ERROR_EXIT_CODES = { + INPUT_INVALID: 1, + CONFIG_INVALID: 1, + FIGMA_AUTH: 1, + FIGMA_NOT_FOUND: 2, + FIGMA_RATE_LIMIT: 2, + NETWORK: 2, + INTERNAL: 3 +}; +function createError(code, message, detail) { + return { + code, + message, + detail: detail ?? null + }; +} +function getExitCode(errors = []) { + if (!errors.length) { + return 0; + } + return errors.reduce((max, error) => { + const exitCode = ERROR_EXIT_CODES[error.code] ?? 1; + return Math.max(max, exitCode); + }, 0); +} + +// coding-tools/figma-tools/js/src/_utils/http-client.ts +var BASE_URL = "https://api.figma.com"; +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} +function parseJsonSafely(text) { + try { + return text ? JSON.parse(text) : {}; + } catch { + return { raw: text }; + } +} +function parseRateLimit(headers, attempts, lastWaitMs) { + const remainingHeader = headers.get("x-ratelimit-remaining"); + const resetHeader = headers.get("x-ratelimit-reset"); + let remaining = null; + if (remainingHeader !== null && remainingHeader !== void 0) { + const parsed = Number(remainingHeader); + remaining = Number.isNaN(parsed) ? null : parsed; + } + let resetAt = null; + if (resetHeader) { + const numericReset = Number(resetHeader); + if (!Number.isNaN(numericReset)) { + resetAt = new Date(numericReset * 1e3).toISOString(); + } else { + const date = new Date(resetHeader); + if (!Number.isNaN(date.valueOf())) { + resetAt = date.toISOString(); + } + } + } + return { + remaining, + resetAt, + attempts, + lastWaitMs + }; +} +function computeBackoffMs(attempt, initialDelayMs) { + return initialDelayMs * 2 ** (attempt - 1); +} +async function figmaRequest(options) { + const { + path, + method = "GET", + token, + headers = {}, + body, + searchParams, + maxAttempts = config_default.http?.maxAttempts ?? 5, + initialDelayMs = config_default.http?.initialDelayMs ?? 250 + } = options; + if (!token) { + return { + ok: false, + error: createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is missing from the environment."), + status: null, + rateLimit: null + }; + } + const url = new URL(path, BASE_URL); + if (searchParams) { + Object.entries(searchParams).forEach(([key, value]) => { + if (value === void 0 || value === null) return; + url.searchParams.append(key, String(value)); + }); + } + let attempt = 0; + let lastWaitMs = 0; + while (attempt < maxAttempts) { + attempt += 1; + const response = await fetch(url, { + method, + headers: { + "Content-Type": "application/json", + "X-Figma-Token": token, + ...headers + }, + body: body ? JSON.stringify(body) : void 0 + }); + const text = await response.text(); + const payload = parseJsonSafely(text); + const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs); + if (response.ok) { + return { ok: true, data: payload, rateLimit }; + } + const status = response.status; + if (status === 401 || status === 403) { + return { ok: false, error: createError("FIGMA_AUTH", payload?.message ?? "Figma token is unauthorized.", { status }), status, rateLimit }; + } + if (status === 404) { + return { ok: false, error: createError("FIGMA_NOT_FOUND", payload?.message ?? "Resource not found.", { status }), status, rateLimit }; + } + if (status === 429 || status >= 500) { + if (attempt >= maxAttempts) { + return { + ok: false, + error: createError(status === 429 ? "FIGMA_RATE_LIMIT" : "NETWORK", payload?.message ?? "Figma request failed after maximum retries.", { status }), + status, + rateLimit + }; + } + let waitMs = computeBackoffMs(attempt, initialDelayMs); + const resetHeader = response.headers.get("x-ratelimit-reset"); + if (resetHeader) { + const asNumber = Number(resetHeader); + if (!Number.isNaN(asNumber)) { + const resetMs = asNumber * 1e3; + const delta = resetMs - Date.now(); + if (delta > 0) waitMs = Math.max(waitMs, delta); + } + } + const jitter = Math.floor(Math.random() * 100); + lastWaitMs = waitMs + jitter; + await sleep(lastWaitMs); + continue; + } + return { ok: false, error: createError("INTERNAL", payload?.message ?? "Unexpected error from Figma API.", { status }), status, rateLimit }; + } + return { + ok: false, + error: createError("NETWORK", "Unable to reach Figma API."), + status: null, + rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs } + }; +} + +// coding-tools/figma-tools/js/src/get-metadata.ts +var TOOL_NAME = "get-metadata"; +function log(message, verbose) { + if (verbose) { + process.stderr.write(`[${TOOL_NAME}] ${message} +`); + } +} +function toOptionalString(value) { + return typeof value === "string" && value.length > 0 ? value : null; +} +function exitWithEnvelope(envelope, errors = []) { + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +function mapNode(node, index = 0, parentId = null) { + const children = Array.isArray(node.children) ? node.children.map((child, idx) => mapNode(child, idx, node.id)) : []; + return { + id: node.id, + name: node.name, + type: node.type, + visible: node.visible ?? true, + locked: node.locked ?? false, + index, + parentId, + characters: node.characters ?? null, + blendMode: node.blendMode ?? null, + opacity: node.opacity ?? 1, + isMask: node.isMask ?? false, + relativeTransform: node.relativeTransform ?? null, + absoluteBoundingBox: node.absoluteBoundingBox ?? null, + size: node.size ?? null, + fills: node.fills ?? [], + strokes: node.strokes ?? [], + strokeWeight: node.strokeWeight ?? null, + strokeAlign: node.strokeAlign ?? null, + effects: node.effects ?? [], + constraints: node.constraints ?? null, + layoutAlign: node.layoutAlign ?? null, + layoutGrow: node.layoutGrow ?? null, + layoutMode: node.layoutMode ?? null, + primaryAxisSizingMode: node.primaryAxisSizingMode ?? null, + counterAxisSizingMode: node.counterAxisSizingMode ?? null, + primaryAxisAlignItems: node.primaryAxisAlignItems ?? null, + counterAxisAlignItems: node.counterAxisAlignItems ?? null, + itemSpacing: node.itemSpacing ?? null, + paddingLeft: node.paddingLeft ?? null, + paddingRight: node.paddingRight ?? null, + paddingTop: node.paddingTop ?? null, + paddingBottom: node.paddingBottom ?? null, + clipsContent: node.clipsContent ?? false, + layoutGrids: node.layoutGrids ?? [], + exportSettings: node.exportSettings ?? [], + transitionNodeID: node.transitionNodeID ?? null, + overlayPositionType: node.overlayPositionType ?? null, + overlayRelativePosition: node.overlayRelativePosition ?? null, + children + }; +} +function escapeXml(value) { + return value.replace(/&/g, "&").replace(//g, ">").replace(/\"/g, """).replace(/'/g, "'"); +} +function nodeToXml(node) { + const attrs = [ + `id="${escapeXml(node.id)}"`, + node.type ? `type="${escapeXml(node.type)}"` : null, + node.name ? `name="${escapeXml(node.name)}"` : null, + node.visible === false ? 'visible="false"' : null, + node.locked ? 'locked="true"' : null, + node.parentId ? `parentId="${escapeXml(node.parentId)}"` : null, + node.absoluteBoundingBox ? `x="${node.absoluteBoundingBox.x ?? 0}" y="${node.absoluteBoundingBox.y ?? 0}" width="${node.absoluteBoundingBox.width ?? 0}" height="${node.absoluteBoundingBox.height ?? 0}"` : null + ].filter(Boolean); + const childXml = node.children.map(nodeToXml).join(""); + return `${childXml}`; +} +async function main() { + const args = parseArgs(); + const verbose = Boolean(args.verbose ?? args.v); + const schemaVersion = toOptionalString(args["schema-version"]) ?? void 0; + const warnings = []; + const errors = []; + const token = process.env.FIGMA_ACCESS_TOKEN; + if (!token || !token.trim()) { + errors.push(createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is required but was not provided.")); + const envelope2 = createEnvelope({ + tool: TOOL_NAME, + input: { fileKey: null, nodeId: null, format: "json" }, + warnings, + errors, + schemaVersion, + data: {} + }); + exitWithEnvelope(envelope2, errors); + } + const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u); + let fileKey = toOptionalString(args["file-key"]) ?? void 0; + let nodeId = ensureNodeId(toOptionalString(args["node-id"])); + if (urlInput) { + const parsed = parseFigmaUrl(urlInput); + fileKey = fileKey || parsed.fileKey || void 0; + nodeId = nodeId || parsed.nodeId; + } + let format = String(args.format ?? "json").toLowerCase(); + let outputMode; + if (format === "json" || format === "xml" || format === "both") { + outputMode = format; + } else { + warnings.push(`Unknown format "${format}". Defaulting to json.`); + outputMode = "json"; + } + const input = { + fileKey: fileKey ?? null, + nodeId: nodeId ?? null, + format: outputMode + }; + if (!fileKey) { + errors.push(createError("INPUT_INVALID", "A valid Figma file key is required (--file-key or --url).")); + } + if (!nodeId) { + errors.push(createError("INPUT_INVALID", "A valid Figma node id is required (--node-id or --url with node-id).")); + } + if (errors.length) { + const envelope2 = createEnvelope({ + tool: TOOL_NAME, + input, + warnings, + errors, + data: {}, + schemaVersion + }); + exitWithEnvelope(envelope2, errors); + } + const resolvedFileKey = fileKey; + const resolvedNodeId = nodeId; + log(`Fetching metadata for node ${resolvedNodeId} in file ${resolvedFileKey}`, verbose); + const nodeResponse = await figmaRequest({ + path: `/v1/files/${resolvedFileKey}/nodes`, + token, + searchParams: { ids: resolvedNodeId } + }); + if (!nodeResponse.ok) { + errors.push(nodeResponse.error ?? createError("INTERNAL", "Failed to fetch node metadata.")); + const envelope2 = createEnvelope({ + tool: TOOL_NAME, + input, + warnings, + errors, + rateLimit: nodeResponse.rateLimit ?? void 0, + data: {}, + schemaVersion + }); + exitWithEnvelope(envelope2, errors); + } + const nodesMap = nodeResponse.data?.nodes ?? {}; + const nodeWrapper = nodesMap[resolvedNodeId]; + if (!nodeWrapper || !nodeWrapper.document) { + errors.push(createError("FIGMA_NOT_FOUND", `Node ${resolvedNodeId} was not found in file ${resolvedFileKey}.`)); + const envelope2 = createEnvelope({ + tool: TOOL_NAME, + input, + warnings, + errors, + rateLimit: nodeResponse.rateLimit ?? void 0, + data: {}, + schemaVersion + }); + exitWithEnvelope(envelope2, errors); + } + const rootNode = nodeWrapper.document; + const metadataTree = mapNode(rootNode); + let xmlDocument; + if (outputMode === "xml" || outputMode === "both") { + xmlDocument = `${nodeToXml(metadataTree)}`; + } + const data = { + file: { + key: resolvedFileKey, + name: nodeResponse.data?.name ?? null, + lastModified: nodeResponse.data?.lastModified ?? null + }, + metadata: metadataTree, + xml: xmlDocument + }; + const envelope = createEnvelope({ + tool: TOOL_NAME, + input, + data, + warnings, + errors, + rateLimit: nodeResponse.rateLimit ?? void 0, + schemaVersion + }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +main().catch((error) => { + const message = error instanceof Error ? error.message : "Unknown error"; + const envelope = createEnvelope({ + tool: TOOL_NAME, + input: { fileKey: null, nodeId: null, format: "json" }, + errors: [createError("INTERNAL", message, { stack: error instanceof Error ? error.stack : void 0 })], + data: {} + }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(3); +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/_utils/cli-args.ts", "../src/_utils/url-parse.ts", "../src/_utils/config.ts", "../src/_utils/envelope.ts", "../src/_utils/errors.ts", "../src/_utils/http-client.ts", "../src/get-metadata.ts"],
  "sourcesContent": ["export type CliArgValue = string | boolean;\n\nexport interface CliArgs {\n  _: string[];\n  [key: string]: CliArgValue | string[];\n}\n\nexport function parseArgs(argv: string[] = process.argv.slice(2)): CliArgs {\n  const args: CliArgs = { _: [] };\n\n  for (let i = 0; i < argv.length; i += 1) {\n    const arg = argv[i];\n\n    if (!arg.startsWith('-') || arg === '-') {\n      args._.push(arg);\n      continue;\n    }\n\n    if (arg === '--') {\n      const remaining = argv.slice(i + 1);\n      args._.push(...remaining);\n      break;\n    }\n\n    const [rawKey, inlineValue] = arg.split('=', 2);\n    const normalisedKey = rawKey.replace(/^-+/, '');\n\n    let value: CliArgValue;\n    if (inlineValue !== undefined) {\n      value = inlineValue;\n    } else {\n      const next = argv[i + 1];\n      if (next !== undefined && !next.startsWith('-')) {\n        value = next;\n        i += 1;\n      } else {\n        value = true;\n      }\n    }\n\n    args[normalisedKey] = value;\n  }\n\n  return args;\n}\n\n", "const FILE_KEY_REGEX = /figma\\.com\\/(?:file|design)\\/([A-Za-z0-9]+)\\//i;\n\nexport interface ParsedFigmaUrl {\n  fileKey: string | null;\n  nodeId: string | null;\n}\n\nexport function parseFigmaUrl(input: string | null | undefined): ParsedFigmaUrl {\n  if (!input) return { fileKey: null, nodeId: null };\n  try {\n    const url = new URL(input);\n    const match = url.href.match(FILE_KEY_REGEX);\n    const fileKey = match ? match[1] : null;\n    const nodeParam = url.searchParams.get('node-id');\n    const nodeId = nodeParam ? ensureNodeId(nodeParam) : null;\n    return { fileKey, nodeId };\n  } catch {\n    return { fileKey: null, nodeId: null };\n  }\n}\n\nexport function ensureNodeId(value: string | null | undefined): string | null {\n  if (!value) return null;\n  const decoded = decodeURIComponent(value);\n  if (decoded.includes(':')) return decoded;\n  if (/^[0-9]+-[0-9]+$/.test(decoded)) {\n    const [left, right] = decoded.split('-', 2);\n    return `${left}:${right}`;\n  }\n  return decoded;\n}\n\n", "export default {\n  schemaVersion: '1.0.0',\n  source: 'agentic-coding-templates/figma-tools',\n  http: {\n    maxAttempts: 5,\n    initialDelayMs: 250,\n  },\n} as const;\n\n", "import config from './config.ts';\nimport type { ToolError } from './errors.ts';\n\nexport interface RateLimitMeta {\n  remaining: number | null;\n  resetAt: string | null;\n  attempts: number;\n  lastWaitMs: number;\n}\n\nexport interface ToolEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  schemaVersion: string;\n  tool: string;\n  input: TInput;\n  meta: {\n    generatedAt: string;\n    source: string;\n    rateLimit: RateLimitMeta;\n  };\n  data: TData;\n  warnings: string[];\n  errors: ToolError[];\n}\n\nexport interface CreateEnvelopeOptions<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  tool: string;\n  input?: TInput;\n  data?: TData;\n  warnings?: string[];\n  errors?: ToolError[];\n  rateLimit?: Partial<RateLimitMeta>;\n  schemaVersion?: string;\n}\n\nfunction buildRateLimitMeta(rateLimit: Partial<RateLimitMeta> = {}): RateLimitMeta {\n  return {\n    remaining: rateLimit.remaining ?? null,\n    resetAt: rateLimit.resetAt ?? null,\n    attempts: rateLimit.attempts ?? 1,\n    lastWaitMs: rateLimit.lastWaitMs ?? 0,\n  };\n}\n\nexport function createEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n>({\n  tool,\n  input = {} as TInput,\n  data = {} as TData,\n  warnings = [],\n  errors = [],\n  rateLimit,\n  schemaVersion,\n}: CreateEnvelopeOptions<TInput, TData>): ToolEnvelope<TInput, TData> {\n  return {\n    schemaVersion: schemaVersion ?? config.schemaVersion,\n    tool,\n    input,\n    meta: {\n      generatedAt: new Date().toISOString(),\n      source: config.source,\n      rateLimit: buildRateLimitMeta(rateLimit),\n    },\n    data,\n    warnings,\n    errors,\n  };\n}\n\n", "export const ERROR_EXIT_CODES = {\n  INPUT_INVALID: 1,\n  CONFIG_INVALID: 1,\n  FIGMA_AUTH: 1,\n  FIGMA_NOT_FOUND: 2,\n  FIGMA_RATE_LIMIT: 2,\n  NETWORK: 2,\n  INTERNAL: 3,\n} as const;\n\nexport type ErrorCode = keyof typeof ERROR_EXIT_CODES;\n\nexport interface ToolError<TDetail = unknown> {\n  code: ErrorCode | string;\n  message: string;\n  detail?: TDetail | null;\n}\n\nexport function createError<TDetail = unknown>(\n  code: ErrorCode | string,\n  message: string,\n  detail?: TDetail | null\n): ToolError<TDetail> {\n  return {\n    code,\n    message,\n    detail: detail ?? null,\n  };\n}\n\nexport function getExitCode(errors: ToolError[] = []): number {\n  if (!errors.length) {\n    return 0;\n  }\n\n  return errors.reduce((max, error) => {\n    const exitCode = ERROR_EXIT_CODES[error.code as ErrorCode] ?? 1;\n    return Math.max(max, exitCode);\n  }, 0);\n}\n\n", "import config from './config.ts';\nimport { createError } from './errors.ts';\nimport type { ToolError } from './errors.ts';\nimport type { RateLimitMeta } from './envelope.ts';\n\nconst BASE_URL = 'https://api.figma.com';\n\ntype SearchParams = Record<string, string | number | boolean | null | undefined>;\n\ninterface FigmaRequestOptions {\n  path: string;\n  method?: string;\n  token?: string;\n  headers?: Record<string, string>;\n  body?: unknown;\n  searchParams?: SearchParams;\n  maxAttempts?: number;\n  initialDelayMs?: number;\n}\n\ninterface FigmaSuccess<TData> {\n  ok: true;\n  data: TData;\n  rateLimit: RateLimitMeta;\n}\n\ninterface FigmaFailure {\n  ok: false;\n  error: ToolError<{ status?: number }>;\n  status?: number | null;\n  rateLimit: RateLimitMeta | null;\n}\n\nexport type FigmaResponse<TData> = FigmaSuccess<TData> | FigmaFailure;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction parseJsonSafely(text: string): unknown {\n  try {\n    return text ? JSON.parse(text) : {};\n  } catch {\n    return { raw: text };\n  }\n}\n\nfunction parseRateLimit(headers: Headers, attempts: number, lastWaitMs: number): RateLimitMeta {\n  const remainingHeader = headers.get('x-ratelimit-remaining');\n  const resetHeader = headers.get('x-ratelimit-reset');\n\n  let remaining: number | null = null;\n  if (remainingHeader !== null && remainingHeader !== undefined) {\n    const parsed = Number(remainingHeader);\n    remaining = Number.isNaN(parsed) ? null : parsed;\n  }\n\n  let resetAt: string | null = null;\n  if (resetHeader) {\n    const numericReset = Number(resetHeader);\n    if (!Number.isNaN(numericReset)) {\n      resetAt = new Date(numericReset * 1000).toISOString();\n    } else {\n      const date = new Date(resetHeader);\n      if (!Number.isNaN(date.valueOf())) {\n        resetAt = date.toISOString();\n      }\n    }\n  }\n\n  return {\n    remaining,\n    resetAt,\n    attempts,\n    lastWaitMs,\n  };\n}\n\nfunction computeBackoffMs(attempt: number, initialDelayMs: number): number {\n  return initialDelayMs * 2 ** (attempt - 1);\n}\n\nexport async function figmaRequest<TData = unknown>(\n  options: FigmaRequestOptions\n): Promise<FigmaResponse<TData>> {\n  const {\n    path,\n    method = 'GET',\n    token,\n    headers = {},\n    body,\n    searchParams,\n    maxAttempts = config.http?.maxAttempts ?? 5,\n    initialDelayMs = config.http?.initialDelayMs ?? 250,\n  } = options;\n\n  if (!token) {\n    return {\n      ok: false,\n      error: createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is missing from the environment.'),\n      status: null,\n      rateLimit: null,\n    };\n  }\n\n  const url = new URL(path, BASE_URL);\n\n  if (searchParams) {\n    Object.entries(searchParams).forEach(([key, value]) => {\n      if (value === undefined || value === null) return;\n      url.searchParams.append(key, String(value));\n    });\n  }\n\n  let attempt = 0;\n  let lastWaitMs = 0;\n\n  while (attempt < maxAttempts) {\n    attempt += 1;\n\n    const response = await fetch(url, {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        'X-Figma-Token': token,\n        ...headers,\n      },\n      body: body ? JSON.stringify(body) : undefined,\n    });\n\n    const text = await response.text();\n    const payload = parseJsonSafely(text) as { message?: string };\n    const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs);\n\n    if (response.ok) {\n      return { ok: true, data: payload as TData, rateLimit };\n    }\n\n    const status = response.status;\n\n    if (status === 401 || status === 403) {\n      return { ok: false, error: createError('FIGMA_AUTH', payload?.message ?? 'Figma token is unauthorized.', { status }), status, rateLimit };\n    }\n\n    if (status === 404) {\n      return { ok: false, error: createError('FIGMA_NOT_FOUND', payload?.message ?? 'Resource not found.', { status }), status, rateLimit };\n    }\n\n    if (status === 429 || status >= 500) {\n      if (attempt >= maxAttempts) {\n        return {\n          ok: false,\n          error: createError(status === 429 ? 'FIGMA_RATE_LIMIT' : 'NETWORK', payload?.message ?? 'Figma request failed after maximum retries.', { status }),\n          status,\n          rateLimit,\n        };\n      }\n\n      let waitMs = computeBackoffMs(attempt, initialDelayMs);\n      const resetHeader = response.headers.get('x-ratelimit-reset');\n      if (resetHeader) {\n        const asNumber = Number(resetHeader);\n        if (!Number.isNaN(asNumber)) {\n          const resetMs = asNumber * 1000;\n          const delta = resetMs - Date.now();\n          if (delta > 0) waitMs = Math.max(waitMs, delta);\n        }\n      }\n\n      const jitter = Math.floor(Math.random() * 100);\n      lastWaitMs = waitMs + jitter;\n      await sleep(lastWaitMs);\n      continue;\n    }\n\n    return { ok: false, error: createError('INTERNAL', payload?.message ?? 'Unexpected error from Figma API.', { status }), status, rateLimit };\n  }\n\n  return {\n    ok: false,\n    error: createError('NETWORK', 'Unable to reach Figma API.'),\n    status: null,\n    rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs },\n  };\n}\n\n", "#!/usr/bin/env node\n\nimport { parseArgs, type CliArgs } from './_utils/cli-args.ts'\nimport { parseFigmaUrl, ensureNodeId } from './_utils/url-parse.ts'\nimport { createEnvelope, type ToolEnvelope } from './_utils/envelope.ts'\nimport { createError, getExitCode, type ToolError } from './_utils/errors.ts'\nimport { figmaRequest } from './_utils/http-client.ts'\n\nconst TOOL_NAME = 'get-metadata'\ntype EmptyData = Record<string, never>\n\ninterface ToolInput extends Record<string, unknown> {\n  fileKey: string | null\n  nodeId: string | null\n  format: string\n}\n\ninterface FigmaNode {\n  id: string\n  name?: string\n  type?: string\n  visible?: boolean\n  locked?: boolean\n  characters?: string\n  blendMode?: string\n  opacity?: number\n  isMask?: boolean\n  relativeTransform?: unknown\n  absoluteBoundingBox?: { x?: number; y?: number; width?: number; height?: number }\n  size?: unknown\n  fills?: unknown[]\n  strokes?: unknown[]\n  strokeWeight?: number\n  strokeAlign?: string\n  effects?: unknown[]\n  constraints?: unknown\n  layoutAlign?: string\n  layoutGrow?: number\n  layoutMode?: string\n  primaryAxisSizingMode?: string\n  counterAxisSizingMode?: string\n  primaryAxisAlignItems?: string\n  counterAxisAlignItems?: string\n  itemSpacing?: number\n  paddingLeft?: number\n  paddingRight?: number\n  paddingTop?: number\n  paddingBottom?: number\n  clipsContent?: boolean\n  layoutGrids?: unknown[]\n  exportSettings?: unknown[]\n  transitionNodeID?: string\n  overlayPositionType?: string\n  overlayRelativePosition?: unknown\n  children?: FigmaNode[]\n}\n\ninterface NodesResponsePayload {\n  name?: string\n  lastModified?: string\n  nodes?: Record<string, { document?: FigmaNode }>\n}\n\ninterface MetadataNode {\n  id: string\n  name?: string\n  type?: string\n  visible: boolean\n  locked: boolean\n  index: number\n  parentId: string | null\n  characters: string | null\n  blendMode: string | null\n  opacity: number\n  isMask: boolean\n  relativeTransform: unknown\n  absoluteBoundingBox: { x?: number; y?: number; width?: number; height?: number } | null\n  size: unknown\n  fills: unknown[]\n  strokes: unknown[]\n  strokeWeight: number | null\n  strokeAlign: string | null\n  effects: unknown[]\n  constraints: unknown\n  layoutAlign: string | null\n  layoutGrow: number | null\n  layoutMode: string | null\n  primaryAxisSizingMode: string | null\n  counterAxisSizingMode: string | null\n  primaryAxisAlignItems: string | null\n  counterAxisAlignItems: string | null\n  itemSpacing: number | null\n  paddingLeft: number | null\n  paddingRight: number | null\n  paddingTop: number | null\n  paddingBottom: number | null\n  clipsContent: boolean\n  layoutGrids: unknown[]\n  exportSettings: unknown[]\n  transitionNodeID: string | null\n  overlayPositionType: string | null\n  overlayRelativePosition: unknown\n  children: MetadataNode[]\n}\n\ninterface MetadataData {\n  file: {\n    key: string\n    name: string | null\n    lastModified: string | null\n  }\n  metadata: MetadataNode\n  xml?: string\n}\n\nfunction log(message: string, verbose: boolean): void {\n  if (verbose) {\n    process.stderr.write(`[${TOOL_NAME}] ${message}\\n`)\n  }\n}\n\nfunction toOptionalString(value: CliArgs[string]): string | null {\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nfunction exitWithEnvelope(\n  envelope: ToolEnvelope<ToolInput, MetadataData | EmptyData>,\n  errors: ToolError[] = []\n): never {\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nfunction mapNode(node: FigmaNode, index = 0, parentId: string | null = null): MetadataNode {\n  const children = Array.isArray(node.children)\n    ? node.children.map((child, idx) => mapNode(child, idx, node.id))\n    : []\n\n  return {\n    id: node.id,\n    name: node.name,\n    type: node.type,\n    visible: node.visible ?? true,\n    locked: node.locked ?? false,\n    index,\n    parentId,\n    characters: node.characters ?? null,\n    blendMode: node.blendMode ?? null,\n    opacity: node.opacity ?? 1,\n    isMask: node.isMask ?? false,\n    relativeTransform: node.relativeTransform ?? null,\n    absoluteBoundingBox: node.absoluteBoundingBox ?? null,\n    size: node.size ?? null,\n    fills: node.fills ?? [],\n    strokes: node.strokes ?? [],\n    strokeWeight: node.strokeWeight ?? null,\n    strokeAlign: node.strokeAlign ?? null,\n    effects: node.effects ?? [],\n    constraints: node.constraints ?? null,\n    layoutAlign: node.layoutAlign ?? null,\n    layoutGrow: node.layoutGrow ?? null,\n    layoutMode: node.layoutMode ?? null,\n    primaryAxisSizingMode: node.primaryAxisSizingMode ?? null,\n    counterAxisSizingMode: node.counterAxisSizingMode ?? null,\n    primaryAxisAlignItems: node.primaryAxisAlignItems ?? null,\n    counterAxisAlignItems: node.counterAxisAlignItems ?? null,\n    itemSpacing: node.itemSpacing ?? null,\n    paddingLeft: node.paddingLeft ?? null,\n    paddingRight: node.paddingRight ?? null,\n    paddingTop: node.paddingTop ?? null,\n    paddingBottom: node.paddingBottom ?? null,\n    clipsContent: node.clipsContent ?? false,\n    layoutGrids: node.layoutGrids ?? [],\n    exportSettings: node.exportSettings ?? [],\n    transitionNodeID: node.transitionNodeID ?? null,\n    overlayPositionType: node.overlayPositionType ?? null,\n    overlayRelativePosition: node.overlayRelativePosition ?? null,\n    children,\n  }\n}\n\nfunction escapeXml(value: string): string {\n  return value\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\\\"/g, '&quot;')\n    .replace(/'/g, '&apos;')\n}\n\nfunction nodeToXml(node: MetadataNode): string {\n  const attrs = [\n    `id=\\\"${escapeXml(node.id)}\\\"`,\n    node.type ? `type=\\\"${escapeXml(node.type)}\\\"` : null,\n    node.name ? `name=\\\"${escapeXml(node.name)}\\\"` : null,\n    node.visible === false ? 'visible=\\\"false\\\"' : null,\n    node.locked ? 'locked=\\\"true\\\"' : null,\n    node.parentId ? `parentId=\\\"${escapeXml(node.parentId)}\\\"` : null,\n    node.absoluteBoundingBox\n      ? `x=\\\"${node.absoluteBoundingBox.x ?? 0}\\\" y=\\\"${node.absoluteBoundingBox.y ?? 0}\\\" width=\\\"${node.absoluteBoundingBox.width ?? 0}\\\" height=\\\"${node.absoluteBoundingBox.height ?? 0}\\\"`\n      : null,\n  ].filter(Boolean)\n\n  const childXml = node.children.map(nodeToXml).join('')\n  return `<node ${attrs.join(' ')}>${childXml}</node>`\n}\n\nasync function main(): Promise<void> {\n  const args = parseArgs()\n  const verbose = Boolean(args.verbose ?? args.v)\n  const schemaVersion = toOptionalString(args['schema-version']) ?? undefined\n\n  const warnings: string[] = []\n  const errors: ToolError[] = []\n\n  const token = process.env.FIGMA_ACCESS_TOKEN\n\n  if (!token || !token.trim()) {\n    errors.push(createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is required but was not provided.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({\n      tool: TOOL_NAME,\n      input: { fileKey: null, nodeId: null, format: 'json' },\n      warnings,\n      errors,\n      schemaVersion,\n      data: {} as EmptyData,\n    })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u)\n  let fileKey = toOptionalString(args['file-key']) ?? undefined\n  let nodeId = ensureNodeId(toOptionalString(args['node-id']))\n\n  if (urlInput) {\n    const parsed = parseFigmaUrl(urlInput)\n    fileKey = fileKey || parsed.fileKey || undefined\n    nodeId = nodeId || parsed.nodeId\n  }\n\n  let format = String(args.format ?? 'json').toLowerCase()\n  let outputMode: 'json' | 'xml' | 'both'\n  if (format === 'json' || format === 'xml' || format === 'both') {\n    outputMode = format as 'json' | 'xml' | 'both'\n  } else {\n    warnings.push(`Unknown format \\\"${format}\\\". Defaulting to json.`)\n    outputMode = 'json'\n  }\n\n  const input: ToolInput = {\n    fileKey: fileKey ?? null,\n    nodeId: nodeId ?? null,\n    format: outputMode,\n  }\n\n  if (!fileKey) {\n    errors.push(createError('INPUT_INVALID', 'A valid Figma file key is required (--file-key or --url).'))\n  }\n\n  if (!nodeId) {\n    errors.push(createError('INPUT_INVALID', 'A valid Figma node id is required (--node-id or --url with node-id).'))\n  }\n\n  if (errors.length) {\n    const envelope = createEnvelope<ToolInput, EmptyData>({\n      tool: TOOL_NAME,\n      input,\n      warnings,\n      errors,\n      data: {} as EmptyData,\n      schemaVersion,\n    })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const resolvedFileKey = fileKey as string\n  const resolvedNodeId = nodeId as string\n\n  log(`Fetching metadata for node ${resolvedNodeId} in file ${resolvedFileKey}`, verbose)\n\n  const nodeResponse = await figmaRequest<NodesResponsePayload>({\n    path: `/v1/files/${resolvedFileKey}/nodes`,\n    token,\n    searchParams: { ids: resolvedNodeId },\n  })\n\n  if (!nodeResponse.ok) {\n    errors.push(nodeResponse.error ?? createError('INTERNAL', 'Failed to fetch node metadata.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({\n      tool: TOOL_NAME,\n      input,\n      warnings,\n      errors,\n      rateLimit: nodeResponse.rateLimit ?? undefined,\n      data: {} as EmptyData,\n      schemaVersion,\n    })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const nodesMap = nodeResponse.data?.nodes ?? {}\n  const nodeWrapper = nodesMap[resolvedNodeId]\n\n  if (!nodeWrapper || !nodeWrapper.document) {\n    errors.push(createError('FIGMA_NOT_FOUND', `Node ${resolvedNodeId} was not found in file ${resolvedFileKey}.`))\n    const envelope = createEnvelope<ToolInput, EmptyData>({\n      tool: TOOL_NAME,\n      input,\n      warnings,\n      errors,\n      rateLimit: nodeResponse.rateLimit ?? undefined,\n      data: {} as EmptyData,\n      schemaVersion,\n    })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const rootNode = nodeWrapper.document\n  const metadataTree = mapNode(rootNode)\n\n  let xmlDocument: string | undefined\n  if (outputMode === 'xml' || outputMode === 'both') {\n    xmlDocument = `<figmaMetadata version=\\\"1.0\\\">${nodeToXml(metadataTree)}</figmaMetadata>`\n  }\n\n  const data: MetadataData = {\n    file: {\n      key: resolvedFileKey,\n      name: nodeResponse.data?.name ?? null,\n      lastModified: nodeResponse.data?.lastModified ?? null,\n    },\n    metadata: metadataTree,\n    xml: xmlDocument,\n  }\n\n  const envelope = createEnvelope<ToolInput, MetadataData>({\n    tool: TOOL_NAME,\n    input,\n    data,\n    warnings,\n    errors,\n    rateLimit: nodeResponse.rateLimit ?? undefined,\n    schemaVersion,\n  })\n\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nmain().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : 'Unknown error'\n  const envelope = createEnvelope<ToolInput, EmptyData>({\n    tool: TOOL_NAME,\n    input: { fileKey: null, nodeId: null, format: 'json' },\n    errors: [createError('INTERNAL', message, { stack: error instanceof Error ? error.stack : undefined })],\n    data: {} as EmptyData,\n  })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(3)\n})\n\n"],
  "mappings": "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",
  "names": ["envelope"]
}
 diff --git a/use-figma/scripts/get-screenshot.mjs b/use-figma/scripts/get-screenshot.mjs new file mode 100755 index 0000000..ae014b4 --- /dev/null +++ b/use-figma/scripts/get-screenshot.mjs @@ -0,0 +1,387 @@ +#!/usr/bin/env node + +// coding-tools/figma-tools/js/src/get-screenshot.ts +import { mkdir, writeFile } from "node:fs/promises"; +import path from "node:path"; + +// coding-tools/figma-tools/js/src/_utils/cli-args.ts +function parseArgs(argv = process.argv.slice(2)) { + const args = { _: [] }; + for (let i = 0; i < argv.length; i += 1) { + const arg = argv[i]; + if (!arg.startsWith("-") || arg === "-") { + args._.push(arg); + continue; + } + if (arg === "--") { + const remaining = argv.slice(i + 1); + args._.push(...remaining); + break; + } + const [rawKey, inlineValue] = arg.split("=", 2); + const normalisedKey = rawKey.replace(/^-+/, ""); + let value; + if (inlineValue !== void 0) { + value = inlineValue; + } else { + const next = argv[i + 1]; + if (next !== void 0 && !next.startsWith("-")) { + value = next; + i += 1; + } else { + value = true; + } + } + args[normalisedKey] = value; + } + return args; +} + +// coding-tools/figma-tools/js/src/_utils/url-parse.ts +var FILE_KEY_REGEX = /figma\.com\/(?:file|design)\/([A-Za-z0-9]+)\//i; +function parseFigmaUrl(input) { + if (!input) return { fileKey: null, nodeId: null }; + try { + const url = new URL(input); + const match = url.href.match(FILE_KEY_REGEX); + const fileKey = match ? match[1] : null; + const nodeParam = url.searchParams.get("node-id"); + const nodeId = nodeParam ? ensureNodeId(nodeParam) : null; + return { fileKey, nodeId }; + } catch { + return { fileKey: null, nodeId: null }; + } +} +function ensureNodeId(value) { + if (!value) return null; + const decoded = decodeURIComponent(value); + if (decoded.includes(":")) return decoded; + if (/^[0-9]+-[0-9]+$/.test(decoded)) { + const [left, right] = decoded.split("-", 2); + return `${left}:${right}`; + } + return decoded; +} + +// coding-tools/figma-tools/js/src/_utils/config.ts +var config_default = { + schemaVersion: "1.0.0", + source: "agentic-coding-templates/figma-tools", + http: { + maxAttempts: 5, + initialDelayMs: 250 + } +}; + +// coding-tools/figma-tools/js/src/_utils/envelope.ts +function buildRateLimitMeta(rateLimit = {}) { + return { + remaining: rateLimit.remaining ?? null, + resetAt: rateLimit.resetAt ?? null, + attempts: rateLimit.attempts ?? 1, + lastWaitMs: rateLimit.lastWaitMs ?? 0 + }; +} +function createEnvelope({ + tool, + input = {}, + data = {}, + warnings = [], + errors = [], + rateLimit, + schemaVersion +}) { + return { + schemaVersion: schemaVersion ?? config_default.schemaVersion, + tool, + input, + meta: { + generatedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: config_default.source, + rateLimit: buildRateLimitMeta(rateLimit) + }, + data, + warnings, + errors + }; +} + +// coding-tools/figma-tools/js/src/_utils/errors.ts +var ERROR_EXIT_CODES = { + INPUT_INVALID: 1, + CONFIG_INVALID: 1, + FIGMA_AUTH: 1, + FIGMA_NOT_FOUND: 2, + FIGMA_RATE_LIMIT: 2, + NETWORK: 2, + INTERNAL: 3 +}; +function createError(code, message, detail) { + return { + code, + message, + detail: detail ?? null + }; +} +function getExitCode(errors = []) { + if (!errors.length) { + return 0; + } + return errors.reduce((max, error) => { + const exitCode = ERROR_EXIT_CODES[error.code] ?? 1; + return Math.max(max, exitCode); + }, 0); +} + +// coding-tools/figma-tools/js/src/_utils/http-client.ts +var BASE_URL = "https://api.figma.com"; +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} +function parseJsonSafely(text) { + try { + return text ? JSON.parse(text) : {}; + } catch { + return { raw: text }; + } +} +function parseRateLimit(headers, attempts, lastWaitMs) { + const remainingHeader = headers.get("x-ratelimit-remaining"); + const resetHeader = headers.get("x-ratelimit-reset"); + let remaining = null; + if (remainingHeader !== null && remainingHeader !== void 0) { + const parsed = Number(remainingHeader); + remaining = Number.isNaN(parsed) ? null : parsed; + } + let resetAt = null; + if (resetHeader) { + const numericReset = Number(resetHeader); + if (!Number.isNaN(numericReset)) { + resetAt = new Date(numericReset * 1e3).toISOString(); + } else { + const date = new Date(resetHeader); + if (!Number.isNaN(date.valueOf())) { + resetAt = date.toISOString(); + } + } + } + return { + remaining, + resetAt, + attempts, + lastWaitMs + }; +} +function computeBackoffMs(attempt, initialDelayMs) { + return initialDelayMs * 2 ** (attempt - 1); +} +async function figmaRequest(options) { + const { + path: path2, + method = "GET", + token, + headers = {}, + body, + searchParams, + maxAttempts = config_default.http?.maxAttempts ?? 5, + initialDelayMs = config_default.http?.initialDelayMs ?? 250 + } = options; + if (!token) { + return { + ok: false, + error: createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is missing from the environment."), + status: null, + rateLimit: null + }; + } + const url = new URL(path2, BASE_URL); + if (searchParams) { + Object.entries(searchParams).forEach(([key, value]) => { + if (value === void 0 || value === null) return; + url.searchParams.append(key, String(value)); + }); + } + let attempt = 0; + let lastWaitMs = 0; + while (attempt < maxAttempts) { + attempt += 1; + const response = await fetch(url, { + method, + headers: { + "Content-Type": "application/json", + "X-Figma-Token": token, + ...headers + }, + body: body ? JSON.stringify(body) : void 0 + }); + const text = await response.text(); + const payload = parseJsonSafely(text); + const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs); + if (response.ok) { + return { ok: true, data: payload, rateLimit }; + } + const status = response.status; + if (status === 401 || status === 403) { + return { ok: false, error: createError("FIGMA_AUTH", payload?.message ?? "Figma token is unauthorized.", { status }), status, rateLimit }; + } + if (status === 404) { + return { ok: false, error: createError("FIGMA_NOT_FOUND", payload?.message ?? "Resource not found.", { status }), status, rateLimit }; + } + if (status === 429 || status >= 500) { + if (attempt >= maxAttempts) { + return { + ok: false, + error: createError(status === 429 ? "FIGMA_RATE_LIMIT" : "NETWORK", payload?.message ?? "Figma request failed after maximum retries.", { status }), + status, + rateLimit + }; + } + let waitMs = computeBackoffMs(attempt, initialDelayMs); + const resetHeader = response.headers.get("x-ratelimit-reset"); + if (resetHeader) { + const asNumber = Number(resetHeader); + if (!Number.isNaN(asNumber)) { + const resetMs = asNumber * 1e3; + const delta = resetMs - Date.now(); + if (delta > 0) waitMs = Math.max(waitMs, delta); + } + } + const jitter = Math.floor(Math.random() * 100); + lastWaitMs = waitMs + jitter; + await sleep(lastWaitMs); + continue; + } + return { ok: false, error: createError("INTERNAL", payload?.message ?? "Unexpected error from Figma API.", { status }), status, rateLimit }; + } + return { + ok: false, + error: createError("NETWORK", "Unable to reach Figma API."), + status: null, + rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs } + }; +} + +// coding-tools/figma-tools/js/src/get-screenshot.ts +var TOOL_NAME = "get-screenshot"; +var SUPPORTED_FORMATS = ["png", "jpg", "jpeg", "svg"]; +var SCREENSHOT_DIR = ".tmp/figma-tools/screenshots"; +function log(message, verbose) { + if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message} +`); +} +function toOptionalString(value) { + return typeof value === "string" && value.length > 0 ? value : null; +} +function exitWithEnvelope(envelope, errors = []) { + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +async function ensureDirExists(dirPath) { + await mkdir(dirPath, { recursive: true }); +} +async function main() { + const args = parseArgs(); + const verbose = Boolean(args.verbose ?? args.v); + const schemaVersion = toOptionalString(args["schema-version"]) ?? void 0; + const warnings = []; + const errors = []; + const token = process.env.FIGMA_ACCESS_TOKEN; + if (!token || !token.trim()) { + errors.push(createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is required but was not provided.")); + const envelope2 = createEnvelope({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null, format: "jpg", scale: 1, bounds: "selection", background: "canvas" }, warnings, errors, schemaVersion, data: {} }); + exitWithEnvelope(envelope2, errors); + } + const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u); + let fileKey = toOptionalString(args["file-key"]) ?? void 0; + let nodeId = ensureNodeId(toOptionalString(args["node-id"])); + if (urlInput) { + const parsed = parseFigmaUrl(urlInput); + fileKey = fileKey || parsed.fileKey || void 0; + nodeId = nodeId || parsed.nodeId; + } + if (!fileKey) errors.push(createError("INPUT_INVALID", "A valid Figma file key is required (--file-key or --url).")); + if (!nodeId) errors.push(createError("INPUT_INVALID", "A valid Figma node id is required (--node-id or --url with node-id).")); + let format = String(args.format ?? "jpg").toLowerCase(); + if (!SUPPORTED_FORMATS.includes(format)) { + warnings.push(`Unsupported format "${format}". Falling back to jpg.`); + format = "jpg"; + } + if (format === "jpeg") format = "jpg"; + const scaleInput = Number(args.scale ?? 1); + const scale = Number.isFinite(scaleInput) ? Math.min(Math.max(scaleInput, 0.01), 1) : 1; + const boundsInput = String(args.bounds ?? "selection").toLowerCase(); + const bounds = ["selection", "frame", "node"].includes(boundsInput) ? boundsInput : "selection"; + const useAbsoluteBounds = bounds === "frame"; + const backgroundInput = String(args.background ?? "canvas").toLowerCase(); + let backgroundParam; + if (backgroundInput === "transparent") backgroundParam = "00000000"; + else if (/^[0-9a-f]{6,8}$/i.test(backgroundInput)) { + const value = backgroundInput.toUpperCase(); + backgroundParam = value.length >= 6 ? value.slice(0, 8).padEnd(8, "F") : void 0; + } else if (backgroundInput.startsWith("#")) backgroundParam = backgroundInput.replace("#", "").slice(0, 8).padEnd(8, "F"); + const input = { fileKey: fileKey ?? null, nodeId: nodeId ?? null, format, scale, bounds, background: backgroundInput }; + if (errors.length) { + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + const resolvedFileKey = fileKey; + const resolvedNodeId = nodeId; + log(`Requesting image for ${resolvedNodeId} (${format}, scale ${scale})`, verbose); + const imageResponse = await figmaRequest({ + path: `/v1/images/${resolvedFileKey}`, + token, + searchParams: { ids: resolvedNodeId, format, scale, use_absolute_bounds: useAbsoluteBounds ? "true" : void 0, background: backgroundParam } + }); + if (!imageResponse.ok) { + errors.push(imageResponse.error ?? createError("INTERNAL", "Failed to request image export.")); + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, rateLimit: imageResponse.rateLimit ?? void 0, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + const imageUrl = imageResponse.data?.images?.[resolvedNodeId]; + if (!imageUrl) { + errors.push(createError("FIGMA_NOT_FOUND", "Figma did not return an image URL for the requested node.")); + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, rateLimit: imageResponse.rateLimit ?? void 0, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + log("Downloading image", verbose); + let buffer = null; + let contentType = null; + try { + const res = await fetch(imageUrl); + if (!res.ok) errors.push(createError("NETWORK", `Unable to download image (status ${res.status}).`)); + else { + contentType = res.headers.get("content-type"); + buffer = format === "svg" ? Buffer.from(await res.text()) : Buffer.from(await res.arrayBuffer()); + } + } catch (error) { + const message = error instanceof Error ? error.message : "Unknown download error"; + errors.push(createError("NETWORK", `Unable to download image: ${message}`)); + } + if (!buffer || errors.length) { + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, rateLimit: imageResponse.rateLimit ?? void 0, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + const sanitizedNodeId = resolvedNodeId.replace(/[^a-zA-Z0-9-_]/g, "_"); + const baseDir = path.resolve(SCREENSHOT_DIR, resolvedFileKey); + await ensureDirExists(baseDir); + const extension = format === "jpg" ? "jpg" : format; + const filePath = path.join(baseDir, `${sanitizedNodeId}.${extension}`); + await writeFile(filePath, buffer); + const data = { + file: { key: resolvedFileKey, nodeId: resolvedNodeId }, + screenshot: { path: filePath, url: imageUrl, format: extension, scale, bounds, background: backgroundInput, contentType } + }; + const envelope = createEnvelope({ tool: TOOL_NAME, input, data, warnings, errors, rateLimit: imageResponse.rateLimit ?? void 0, schemaVersion }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +main().catch((error) => { + const message = error instanceof Error ? error.message : "Unknown error"; + const envelope = createEnvelope({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null, format: "jpg", scale: 1, bounds: "selection", background: "canvas" }, errors: [createError("INTERNAL", message, { stack: error instanceof Error ? error.stack : void 0 })], data: {} }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(3); +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/get-screenshot.ts", "../src/_utils/cli-args.ts", "../src/_utils/url-parse.ts", "../src/_utils/config.ts", "../src/_utils/envelope.ts", "../src/_utils/errors.ts", "../src/_utils/http-client.ts"],
  "sourcesContent": ["#!/usr/bin/env node\n\nimport { mkdir, writeFile } from 'node:fs/promises'\nimport path from 'node:path'\nimport { parseArgs, type CliArgs } from './_utils/cli-args.ts'\nimport { parseFigmaUrl, ensureNodeId } from './_utils/url-parse.ts'\nimport { createEnvelope, type ToolEnvelope } from './_utils/envelope.ts'\nimport { createError, getExitCode, type ToolError } from './_utils/errors.ts'\nimport { figmaRequest } from './_utils/http-client.ts'\n\nconst TOOL_NAME = 'get-screenshot'\nconst SUPPORTED_FORMATS = ['png', 'jpg', 'jpeg', 'svg']\nconst SCREENSHOT_DIR = '.tmp/figma-tools/screenshots'\ntype EmptyData = Record<string, never>\n\ninterface ToolInput extends Record<string, unknown> {\n  fileKey: string | null\n  nodeId: string | null\n  format: string\n  scale: number\n  bounds: string\n  background: string\n}\n\ninterface ImageExportResponse { images?: Record<string, string> }\n\ninterface ScreenshotData {\n  file: { key: string; nodeId: string }\n  screenshot: {\n    path: string\n    url: string\n    format: string\n    scale: number\n    bounds: string\n    background: string\n    contentType: string | null\n  }\n}\n\nfunction log(message: string, verbose: boolean): void {\n  if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message}\\n`)\n}\n\nfunction toOptionalString(value: CliArgs[string]): string | null {\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nfunction exitWithEnvelope(\n  envelope: ToolEnvelope<ToolInput, ScreenshotData | EmptyData>,\n  errors: ToolError[] = []\n): never {\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nasync function ensureDirExists(dirPath: string): Promise<void> { await mkdir(dirPath, { recursive: true }) }\n\nasync function main(): Promise<void> {\n  const args = parseArgs()\n  const verbose = Boolean(args.verbose ?? args.v)\n  const schemaVersion = toOptionalString(args['schema-version']) ?? undefined\n\n  const warnings: string[] = []\n  const errors: ToolError[] = []\n\n  const token = process.env.FIGMA_ACCESS_TOKEN\n  if (!token || !token.trim()) {\n    errors.push(createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is required but was not provided.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null, format: 'jpg', scale: 1, bounds: 'selection', background: 'canvas' }, warnings, errors, schemaVersion, data: {} as EmptyData })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u)\n  let fileKey = toOptionalString(args['file-key']) ?? undefined\n  let nodeId = ensureNodeId(toOptionalString(args['node-id']))\n  if (urlInput) {\n    const parsed = parseFigmaUrl(urlInput)\n    fileKey = fileKey || parsed.fileKey || undefined\n    nodeId = nodeId || parsed.nodeId\n  }\n\n  if (!fileKey) errors.push(createError('INPUT_INVALID', 'A valid Figma file key is required (--file-key or --url).'))\n  if (!nodeId) errors.push(createError('INPUT_INVALID', 'A valid Figma node id is required (--node-id or --url with node-id).'))\n\n  let format = String(args.format ?? 'jpg').toLowerCase()\n  if (!SUPPORTED_FORMATS.includes(format)) { warnings.push(`Unsupported format \"${format}\". Falling back to jpg.`); format = 'jpg' }\n  if (format === 'jpeg') format = 'jpg'\n\n  const scaleInput = Number(args.scale ?? 1)\n  const scale = Number.isFinite(scaleInput) ? Math.min(Math.max(scaleInput, 0.01), 1) : 1\n\n  const boundsInput = String(args.bounds ?? 'selection').toLowerCase()\n  const bounds = ['selection', 'frame', 'node'].includes(boundsInput) ? boundsInput : 'selection'\n  const useAbsoluteBounds = bounds === 'frame'\n\n  const backgroundInput = String(args.background ?? 'canvas').toLowerCase()\n  let backgroundParam: string | undefined\n  if (backgroundInput === 'transparent') backgroundParam = '00000000'\n  else if (/^[0-9a-f]{6,8}$/i.test(backgroundInput)) { const value = backgroundInput.toUpperCase(); backgroundParam = value.length >= 6 ? value.slice(0, 8).padEnd(8, 'F') : undefined }\n  else if (backgroundInput.startsWith('#')) backgroundParam = backgroundInput.replace('#', '').slice(0, 8).padEnd(8, 'F')\n\n  const input: ToolInput = { fileKey: fileKey ?? null, nodeId: nodeId ?? null, format, scale, bounds, background: backgroundInput }\n  if (errors.length) { const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, data: {} as EmptyData, schemaVersion }); exitWithEnvelope(envelope, errors) }\n\n  const resolvedFileKey = fileKey as string\n  const resolvedNodeId = nodeId as string\n\n  log(`Requesting image for ${resolvedNodeId} (${format}, scale ${scale})`, verbose)\n  const imageResponse = await figmaRequest<ImageExportResponse>({\n    path: `/v1/images/${resolvedFileKey}`,\n    token,\n    searchParams: { ids: resolvedNodeId, format, scale, use_absolute_bounds: useAbsoluteBounds ? 'true' : undefined, background: backgroundParam },\n  })\n\n  if (!imageResponse.ok) {\n    errors.push(imageResponse.error ?? createError('INTERNAL', 'Failed to request image export.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, rateLimit: imageResponse.rateLimit ?? undefined, data: {} as EmptyData, schemaVersion })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const imageUrl = imageResponse.data?.images?.[resolvedNodeId]\n  if (!imageUrl) {\n    errors.push(createError('FIGMA_NOT_FOUND', 'Figma did not return an image URL for the requested node.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, rateLimit: imageResponse.rateLimit ?? undefined, data: {} as EmptyData, schemaVersion })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  log('Downloading image', verbose)\n  let buffer: Buffer | null = null\n  let contentType: string | null = null\n  try {\n    const res = await fetch(imageUrl)\n    if (!res.ok) errors.push(createError('NETWORK', `Unable to download image (status ${res.status}).`))\n    else { contentType = res.headers.get('content-type'); buffer = (format === 'svg') ? Buffer.from(await res.text()) : Buffer.from(await res.arrayBuffer()) }\n  } catch (error) {\n    const message = error instanceof Error ? error.message : 'Unknown download error'\n    errors.push(createError('NETWORK', `Unable to download image: ${message}`))\n  }\n\n  if (!buffer || errors.length) {\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, rateLimit: imageResponse.rateLimit ?? undefined, data: {} as EmptyData, schemaVersion })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const sanitizedNodeId = resolvedNodeId.replace(/[^a-zA-Z0-9-_]/g, '_')\n  const baseDir = path.resolve(SCREENSHOT_DIR, resolvedFileKey)\n  await ensureDirExists(baseDir)\n  const extension = format === 'jpg' ? 'jpg' : format\n  const filePath = path.join(baseDir, `${sanitizedNodeId}.${extension}`)\n  await writeFile(filePath, buffer)\n\n  const data: ScreenshotData = {\n    file: { key: resolvedFileKey, nodeId: resolvedNodeId },\n    screenshot: { path: filePath, url: imageUrl, format: extension, scale, bounds, background: backgroundInput, contentType },\n  }\n\n  const envelope = createEnvelope<ToolInput, ScreenshotData>({ tool: TOOL_NAME, input, data, warnings, errors, rateLimit: imageResponse.rateLimit ?? undefined, schemaVersion })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nmain().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : 'Unknown error'\n  const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input: { fileKey: null, nodeId: null, format: 'jpg', scale: 1, bounds: 'selection', background: 'canvas' }, errors: [createError('INTERNAL', message, { stack: error instanceof Error ? error.stack : undefined })], data: {} as EmptyData })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(3)\n})\n", "export type CliArgValue = string | boolean;\n\nexport interface CliArgs {\n  _: string[];\n  [key: string]: CliArgValue | string[];\n}\n\nexport function parseArgs(argv: string[] = process.argv.slice(2)): CliArgs {\n  const args: CliArgs = { _: [] };\n\n  for (let i = 0; i < argv.length; i += 1) {\n    const arg = argv[i];\n\n    if (!arg.startsWith('-') || arg === '-') {\n      args._.push(arg);\n      continue;\n    }\n\n    if (arg === '--') {\n      const remaining = argv.slice(i + 1);\n      args._.push(...remaining);\n      break;\n    }\n\n    const [rawKey, inlineValue] = arg.split('=', 2);\n    const normalisedKey = rawKey.replace(/^-+/, '');\n\n    let value: CliArgValue;\n    if (inlineValue !== undefined) {\n      value = inlineValue;\n    } else {\n      const next = argv[i + 1];\n      if (next !== undefined && !next.startsWith('-')) {\n        value = next;\n        i += 1;\n      } else {\n        value = true;\n      }\n    }\n\n    args[normalisedKey] = value;\n  }\n\n  return args;\n}\n\n", "const FILE_KEY_REGEX = /figma\\.com\\/(?:file|design)\\/([A-Za-z0-9]+)\\//i;\n\nexport interface ParsedFigmaUrl {\n  fileKey: string | null;\n  nodeId: string | null;\n}\n\nexport function parseFigmaUrl(input: string | null | undefined): ParsedFigmaUrl {\n  if (!input) return { fileKey: null, nodeId: null };\n  try {\n    const url = new URL(input);\n    const match = url.href.match(FILE_KEY_REGEX);\n    const fileKey = match ? match[1] : null;\n    const nodeParam = url.searchParams.get('node-id');\n    const nodeId = nodeParam ? ensureNodeId(nodeParam) : null;\n    return { fileKey, nodeId };\n  } catch {\n    return { fileKey: null, nodeId: null };\n  }\n}\n\nexport function ensureNodeId(value: string | null | undefined): string | null {\n  if (!value) return null;\n  const decoded = decodeURIComponent(value);\n  if (decoded.includes(':')) return decoded;\n  if (/^[0-9]+-[0-9]+$/.test(decoded)) {\n    const [left, right] = decoded.split('-', 2);\n    return `${left}:${right}`;\n  }\n  return decoded;\n}\n\n", "export default {\n  schemaVersion: '1.0.0',\n  source: 'agentic-coding-templates/figma-tools',\n  http: {\n    maxAttempts: 5,\n    initialDelayMs: 250,\n  },\n} as const;\n\n", "import config from './config.ts';\nimport type { ToolError } from './errors.ts';\n\nexport interface RateLimitMeta {\n  remaining: number | null;\n  resetAt: string | null;\n  attempts: number;\n  lastWaitMs: number;\n}\n\nexport interface ToolEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  schemaVersion: string;\n  tool: string;\n  input: TInput;\n  meta: {\n    generatedAt: string;\n    source: string;\n    rateLimit: RateLimitMeta;\n  };\n  data: TData;\n  warnings: string[];\n  errors: ToolError[];\n}\n\nexport interface CreateEnvelopeOptions<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  tool: string;\n  input?: TInput;\n  data?: TData;\n  warnings?: string[];\n  errors?: ToolError[];\n  rateLimit?: Partial<RateLimitMeta>;\n  schemaVersion?: string;\n}\n\nfunction buildRateLimitMeta(rateLimit: Partial<RateLimitMeta> = {}): RateLimitMeta {\n  return {\n    remaining: rateLimit.remaining ?? null,\n    resetAt: rateLimit.resetAt ?? null,\n    attempts: rateLimit.attempts ?? 1,\n    lastWaitMs: rateLimit.lastWaitMs ?? 0,\n  };\n}\n\nexport function createEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n>({\n  tool,\n  input = {} as TInput,\n  data = {} as TData,\n  warnings = [],\n  errors = [],\n  rateLimit,\n  schemaVersion,\n}: CreateEnvelopeOptions<TInput, TData>): ToolEnvelope<TInput, TData> {\n  return {\n    schemaVersion: schemaVersion ?? config.schemaVersion,\n    tool,\n    input,\n    meta: {\n      generatedAt: new Date().toISOString(),\n      source: config.source,\n      rateLimit: buildRateLimitMeta(rateLimit),\n    },\n    data,\n    warnings,\n    errors,\n  };\n}\n\n", "export const ERROR_EXIT_CODES = {\n  INPUT_INVALID: 1,\n  CONFIG_INVALID: 1,\n  FIGMA_AUTH: 1,\n  FIGMA_NOT_FOUND: 2,\n  FIGMA_RATE_LIMIT: 2,\n  NETWORK: 2,\n  INTERNAL: 3,\n} as const;\n\nexport type ErrorCode = keyof typeof ERROR_EXIT_CODES;\n\nexport interface ToolError<TDetail = unknown> {\n  code: ErrorCode | string;\n  message: string;\n  detail?: TDetail | null;\n}\n\nexport function createError<TDetail = unknown>(\n  code: ErrorCode | string,\n  message: string,\n  detail?: TDetail | null\n): ToolError<TDetail> {\n  return {\n    code,\n    message,\n    detail: detail ?? null,\n  };\n}\n\nexport function getExitCode(errors: ToolError[] = []): number {\n  if (!errors.length) {\n    return 0;\n  }\n\n  return errors.reduce((max, error) => {\n    const exitCode = ERROR_EXIT_CODES[error.code as ErrorCode] ?? 1;\n    return Math.max(max, exitCode);\n  }, 0);\n}\n\n", "import config from './config.ts';\nimport { createError } from './errors.ts';\nimport type { ToolError } from './errors.ts';\nimport type { RateLimitMeta } from './envelope.ts';\n\nconst BASE_URL = 'https://api.figma.com';\n\ntype SearchParams = Record<string, string | number | boolean | null | undefined>;\n\ninterface FigmaRequestOptions {\n  path: string;\n  method?: string;\n  token?: string;\n  headers?: Record<string, string>;\n  body?: unknown;\n  searchParams?: SearchParams;\n  maxAttempts?: number;\n  initialDelayMs?: number;\n}\n\ninterface FigmaSuccess<TData> {\n  ok: true;\n  data: TData;\n  rateLimit: RateLimitMeta;\n}\n\ninterface FigmaFailure {\n  ok: false;\n  error: ToolError<{ status?: number }>;\n  status?: number | null;\n  rateLimit: RateLimitMeta | null;\n}\n\nexport type FigmaResponse<TData> = FigmaSuccess<TData> | FigmaFailure;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction parseJsonSafely(text: string): unknown {\n  try {\n    return text ? JSON.parse(text) : {};\n  } catch {\n    return { raw: text };\n  }\n}\n\nfunction parseRateLimit(headers: Headers, attempts: number, lastWaitMs: number): RateLimitMeta {\n  const remainingHeader = headers.get('x-ratelimit-remaining');\n  const resetHeader = headers.get('x-ratelimit-reset');\n\n  let remaining: number | null = null;\n  if (remainingHeader !== null && remainingHeader !== undefined) {\n    const parsed = Number(remainingHeader);\n    remaining = Number.isNaN(parsed) ? null : parsed;\n  }\n\n  let resetAt: string | null = null;\n  if (resetHeader) {\n    const numericReset = Number(resetHeader);\n    if (!Number.isNaN(numericReset)) {\n      resetAt = new Date(numericReset * 1000).toISOString();\n    } else {\n      const date = new Date(resetHeader);\n      if (!Number.isNaN(date.valueOf())) {\n        resetAt = date.toISOString();\n      }\n    }\n  }\n\n  return {\n    remaining,\n    resetAt,\n    attempts,\n    lastWaitMs,\n  };\n}\n\nfunction computeBackoffMs(attempt: number, initialDelayMs: number): number {\n  return initialDelayMs * 2 ** (attempt - 1);\n}\n\nexport async function figmaRequest<TData = unknown>(\n  options: FigmaRequestOptions\n): Promise<FigmaResponse<TData>> {\n  const {\n    path,\n    method = 'GET',\n    token,\n    headers = {},\n    body,\n    searchParams,\n    maxAttempts = config.http?.maxAttempts ?? 5,\n    initialDelayMs = config.http?.initialDelayMs ?? 250,\n  } = options;\n\n  if (!token) {\n    return {\n      ok: false,\n      error: createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is missing from the environment.'),\n      status: null,\n      rateLimit: null,\n    };\n  }\n\n  const url = new URL(path, BASE_URL);\n\n  if (searchParams) {\n    Object.entries(searchParams).forEach(([key, value]) => {\n      if (value === undefined || value === null) return;\n      url.searchParams.append(key, String(value));\n    });\n  }\n\n  let attempt = 0;\n  let lastWaitMs = 0;\n\n  while (attempt < maxAttempts) {\n    attempt += 1;\n\n    const response = await fetch(url, {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        'X-Figma-Token': token,\n        ...headers,\n      },\n      body: body ? JSON.stringify(body) : undefined,\n    });\n\n    const text = await response.text();\n    const payload = parseJsonSafely(text) as { message?: string };\n    const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs);\n\n    if (response.ok) {\n      return { ok: true, data: payload as TData, rateLimit };\n    }\n\n    const status = response.status;\n\n    if (status === 401 || status === 403) {\n      return { ok: false, error: createError('FIGMA_AUTH', payload?.message ?? 'Figma token is unauthorized.', { status }), status, rateLimit };\n    }\n\n    if (status === 404) {\n      return { ok: false, error: createError('FIGMA_NOT_FOUND', payload?.message ?? 'Resource not found.', { status }), status, rateLimit };\n    }\n\n    if (status === 429 || status >= 500) {\n      if (attempt >= maxAttempts) {\n        return {\n          ok: false,\n          error: createError(status === 429 ? 'FIGMA_RATE_LIMIT' : 'NETWORK', payload?.message ?? 'Figma request failed after maximum retries.', { status }),\n          status,\n          rateLimit,\n        };\n      }\n\n      let waitMs = computeBackoffMs(attempt, initialDelayMs);\n      const resetHeader = response.headers.get('x-ratelimit-reset');\n      if (resetHeader) {\n        const asNumber = Number(resetHeader);\n        if (!Number.isNaN(asNumber)) {\n          const resetMs = asNumber * 1000;\n          const delta = resetMs - Date.now();\n          if (delta > 0) waitMs = Math.max(waitMs, delta);\n        }\n      }\n\n      const jitter = Math.floor(Math.random() * 100);\n      lastWaitMs = waitMs + jitter;\n      await sleep(lastWaitMs);\n      continue;\n    }\n\n    return { ok: false, error: createError('INTERNAL', payload?.message ?? 'Unexpected error from Figma API.', { status }), status, rateLimit };\n  }\n\n  return {\n    ok: false,\n    error: createError('NETWORK', 'Unable to reach Figma API.'),\n    status: null,\n    rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs },\n  };\n}\n\n"],
  "mappings": ";;;AAEA,SAAS,OAAO,iBAAiB;AACjC,OAAO,UAAU;;;ACIV,SAAS,UAAU,OAAiB,QAAQ,KAAK,MAAM,CAAC,GAAY;AACzE,QAAM,OAAgB,EAAE,GAAG,CAAC,EAAE;AAE9B,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GAAG;AACvC,UAAM,MAAM,KAAK,CAAC;AAElB,QAAI,CAAC,IAAI,WAAW,GAAG,KAAK,QAAQ,KAAK;AACvC,WAAK,EAAE,KAAK,GAAG;AACf;AAAA,IACF;AAEA,QAAI,QAAQ,MAAM;AAChB,YAAM,YAAY,KAAK,MAAM,IAAI,CAAC;AAClC,WAAK,EAAE,KAAK,GAAG,SAAS;AACxB;AAAA,IACF;AAEA,UAAM,CAAC,QAAQ,WAAW,IAAI,IAAI,MAAM,KAAK,CAAC;AAC9C,UAAM,gBAAgB,OAAO,QAAQ,OAAO,EAAE;AAE9C,QAAI;AACJ,QAAI,gBAAgB,QAAW;AAC7B,cAAQ;AAAA,IACV,OAAO;AACL,YAAM,OAAO,KAAK,IAAI,CAAC;AACvB,UAAI,SAAS,UAAa,CAAC,KAAK,WAAW,GAAG,GAAG;AAC/C,gBAAQ;AACR,aAAK;AAAA,MACP,OAAO;AACL,gBAAQ;AAAA,MACV;AAAA,IACF;AAEA,SAAK,aAAa,IAAI;AAAA,EACxB;AAEA,SAAO;AACT;;;AC5CA,IAAM,iBAAiB;AAOhB,SAAS,cAAc,OAAkD;AAC9E,MAAI,CAAC,MAAO,QAAO,EAAE,SAAS,MAAM,QAAQ,KAAK;AACjD,MAAI;AACF,UAAM,MAAM,IAAI,IAAI,KAAK;AACzB,UAAM,QAAQ,IAAI,KAAK,MAAM,cAAc;AAC3C,UAAM,UAAU,QAAQ,MAAM,CAAC,IAAI;AACnC,UAAM,YAAY,IAAI,aAAa,IAAI,SAAS;AAChD,UAAM,SAAS,YAAY,aAAa,SAAS,IAAI;AACrD,WAAO,EAAE,SAAS,OAAO;AAAA,EAC3B,QAAQ;AACN,WAAO,EAAE,SAAS,MAAM,QAAQ,KAAK;AAAA,EACvC;AACF;AAEO,SAAS,aAAa,OAAiD;AAC5E,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,UAAU,mBAAmB,KAAK;AACxC,MAAI,QAAQ,SAAS,GAAG,EAAG,QAAO;AAClC,MAAI,kBAAkB,KAAK,OAAO,GAAG;AACnC,UAAM,CAAC,MAAM,KAAK,IAAI,QAAQ,MAAM,KAAK,CAAC;AAC1C,WAAO,GAAG,IAAI,IAAI,KAAK;AAAA,EACzB;AACA,SAAO;AACT;;;AC9BA,IAAO,iBAAQ;AAAA,EACb,eAAe;AAAA,EACf,QAAQ;AAAA,EACR,MAAM;AAAA,IACJ,aAAa;AAAA,IACb,gBAAgB;AAAA,EAClB;AACF;;;ACiCA,SAAS,mBAAmB,YAAoC,CAAC,GAAkB;AACjF,SAAO;AAAA,IACL,WAAW,UAAU,aAAa;AAAA,IAClC,SAAS,UAAU,WAAW;AAAA,IAC9B,UAAU,UAAU,YAAY;AAAA,IAChC,YAAY,UAAU,cAAc;AAAA,EACtC;AACF;AAEO,SAAS,eAGd;AAAA,EACA;AAAA,EACA,QAAQ,CAAC;AAAA,EACT,OAAO,CAAC;AAAA,EACR,WAAW,CAAC;AAAA,EACZ,SAAS,CAAC;AAAA,EACV;AAAA,EACA;AACF,GAAsE;AACpE,SAAO;AAAA,IACL,eAAe,iBAAiB,eAAO;AAAA,IACvC;AAAA,IACA;AAAA,IACA,MAAM;AAAA,MACJ,cAAa,oBAAI,KAAK,GAAE,YAAY;AAAA,MACpC,QAAQ,eAAO;AAAA,MACf,WAAW,mBAAmB,SAAS;AAAA,IACzC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;;AC1EO,IAAM,mBAAmB;AAAA,EAC9B,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,iBAAiB;AAAA,EACjB,kBAAkB;AAAA,EAClB,SAAS;AAAA,EACT,UAAU;AACZ;AAUO,SAAS,YACd,MACA,SACA,QACoB;AACpB,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,QAAQ,UAAU;AAAA,EACpB;AACF;AAEO,SAAS,YAAY,SAAsB,CAAC,GAAW;AAC5D,MAAI,CAAC,OAAO,QAAQ;AAClB,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,OAAO,CAAC,KAAK,UAAU;AACnC,UAAM,WAAW,iBAAiB,MAAM,IAAiB,KAAK;AAC9D,WAAO,KAAK,IAAI,KAAK,QAAQ;AAAA,EAC/B,GAAG,CAAC;AACN;;;AClCA,IAAM,WAAW;AA8BjB,SAAS,MAAM,IAA2B;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AACzD;AAEA,SAAS,gBAAgB,MAAuB;AAC9C,MAAI;AACF,WAAO,OAAO,KAAK,MAAM,IAAI,IAAI,CAAC;AAAA,EACpC,QAAQ;AACN,WAAO,EAAE,KAAK,KAAK;AAAA,EACrB;AACF;AAEA,SAAS,eAAe,SAAkB,UAAkB,YAAmC;AAC7F,QAAM,kBAAkB,QAAQ,IAAI,uBAAuB;AAC3D,QAAM,cAAc,QAAQ,IAAI,mBAAmB;AAEnD,MAAI,YAA2B;AAC/B,MAAI,oBAAoB,QAAQ,oBAAoB,QAAW;AAC7D,UAAM,SAAS,OAAO,eAAe;AACrC,gBAAY,OAAO,MAAM,MAAM,IAAI,OAAO;AAAA,EAC5C;AAEA,MAAI,UAAyB;AAC7B,MAAI,aAAa;AACf,UAAM,eAAe,OAAO,WAAW;AACvC,QAAI,CAAC,OAAO,MAAM,YAAY,GAAG;AAC/B,gBAAU,IAAI,KAAK,eAAe,GAAI,EAAE,YAAY;AAAA,IACtD,OAAO;AACL,YAAM,OAAO,IAAI,KAAK,WAAW;AACjC,UAAI,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC,GAAG;AACjC,kBAAU,KAAK,YAAY;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEA,SAAS,iBAAiB,SAAiB,gBAAgC;AACzE,SAAO,iBAAiB,MAAM,UAAU;AAC1C;AAEA,eAAsB,aACpB,SAC+B;AAC/B,QAAM;AAAA,IACJ,MAAAA;AAAA,IACA,SAAS;AAAA,IACT;AAAA,IACA,UAAU,CAAC;AAAA,IACX;AAAA,IACA;AAAA,IACA,cAAc,eAAO,MAAM,eAAe;AAAA,IAC1C,iBAAiB,eAAO,MAAM,kBAAkB;AAAA,EAClD,IAAI;AAEJ,MAAI,CAAC,OAAO;AACV,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,OAAO,YAAY,cAAc,qDAAqD;AAAA,MACtF,QAAQ;AAAA,MACR,WAAW;AAAA,IACb;AAAA,EACF;AAEA,QAAM,MAAM,IAAI,IAAIA,OAAM,QAAQ;AAElC,MAAI,cAAc;AAChB,WAAO,QAAQ,YAAY,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AACrD,UAAI,UAAU,UAAa,UAAU,KAAM;AAC3C,UAAI,aAAa,OAAO,KAAK,OAAO,KAAK,CAAC;AAAA,IAC5C,CAAC;AAAA,EACH;AAEA,MAAI,UAAU;AACd,MAAI,aAAa;AAEjB,SAAO,UAAU,aAAa;AAC5B,eAAW;AAEX,UAAM,WAAW,MAAM,MAAM,KAAK;AAAA,MAChC;AAAA,MACA,SAAS;AAAA,QACP,gBAAgB;AAAA,QAChB,iBAAiB;AAAA,QACjB,GAAG;AAAA,MACL;AAAA,MACA,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;AAAA,IACtC,CAAC;AAED,UAAM,OAAO,MAAM,SAAS,KAAK;AACjC,UAAM,UAAU,gBAAgB,IAAI;AACpC,UAAM,YAAY,eAAe,SAAS,SAAS,SAAS,UAAU;AAEtE,QAAI,SAAS,IAAI;AACf,aAAO,EAAE,IAAI,MAAM,MAAM,SAAkB,UAAU;AAAA,IACvD;AAEA,UAAM,SAAS,SAAS;AAExB,QAAI,WAAW,OAAO,WAAW,KAAK;AACpC,aAAO,EAAE,IAAI,OAAO,OAAO,YAAY,cAAc,SAAS,WAAW,gCAAgC,EAAE,OAAO,CAAC,GAAG,QAAQ,UAAU;AAAA,IAC1I;AAEA,QAAI,WAAW,KAAK;AAClB,aAAO,EAAE,IAAI,OAAO,OAAO,YAAY,mBAAmB,SAAS,WAAW,uBAAuB,EAAE,OAAO,CAAC,GAAG,QAAQ,UAAU;AAAA,IACtI;AAEA,QAAI,WAAW,OAAO,UAAU,KAAK;AACnC,UAAI,WAAW,aAAa;AAC1B,eAAO;AAAA,UACL,IAAI;AAAA,UACJ,OAAO,YAAY,WAAW,MAAM,qBAAqB,WAAW,SAAS,WAAW,+CAA+C,EAAE,OAAO,CAAC;AAAA,UACjJ;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAEA,UAAI,SAAS,iBAAiB,SAAS,cAAc;AACrD,YAAM,cAAc,SAAS,QAAQ,IAAI,mBAAmB;AAC5D,UAAI,aAAa;AACf,cAAM,WAAW,OAAO,WAAW;AACnC,YAAI,CAAC,OAAO,MAAM,QAAQ,GAAG;AAC3B,gBAAM,UAAU,WAAW;AAC3B,gBAAM,QAAQ,UAAU,KAAK,IAAI;AACjC,cAAI,QAAQ,EAAG,UAAS,KAAK,IAAI,QAAQ,KAAK;AAAA,QAChD;AAAA,MACF;AAEA,YAAM,SAAS,KAAK,MAAM,KAAK,OAAO,IAAI,GAAG;AAC7C,mBAAa,SAAS;AACtB,YAAM,MAAM,UAAU;AACtB;AAAA,IACF;AAEA,WAAO,EAAE,IAAI,OAAO,OAAO,YAAY,YAAY,SAAS,WAAW,oCAAoC,EAAE,OAAO,CAAC,GAAG,QAAQ,UAAU;AAAA,EAC5I;AAEA,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,OAAO,YAAY,WAAW,4BAA4B;AAAA,IAC1D,QAAQ;AAAA,IACR,WAAW,EAAE,WAAW,MAAM,SAAS,MAAM,UAAU,aAAa,WAAW;AAAA,EACjF;AACF;;;AN9KA,IAAM,YAAY;AAClB,IAAM,oBAAoB,CAAC,OAAO,OAAO,QAAQ,KAAK;AACtD,IAAM,iBAAiB;AA2BvB,SAAS,IAAI,SAAiB,SAAwB;AACpD,MAAI,QAAS,SAAQ,OAAO,MAAM,IAAI,SAAS,KAAK,OAAO;AAAA,CAAI;AACjE;AAEA,SAAS,iBAAiB,OAAuC;AAC/D,SAAO,OAAO,UAAU,YAAY,MAAM,SAAS,IAAI,QAAQ;AACjE;AAEA,SAAS,iBACP,UACA,SAAsB,CAAC,GAChB;AACP,UAAQ,OAAO,MAAM,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,CAAI;AAC7D,UAAQ,KAAK,YAAY,MAAM,CAAC;AAClC;AAEA,eAAe,gBAAgB,SAAgC;AAAE,QAAM,MAAM,SAAS,EAAE,WAAW,KAAK,CAAC;AAAE;AAE3G,eAAe,OAAsB;AACnC,QAAM,OAAO,UAAU;AACvB,QAAM,UAAU,QAAQ,KAAK,WAAW,KAAK,CAAC;AAC9C,QAAM,gBAAgB,iBAAiB,KAAK,gBAAgB,CAAC,KAAK;AAElE,QAAM,WAAqB,CAAC;AAC5B,QAAM,SAAsB,CAAC;AAE7B,QAAM,QAAQ,QAAQ,IAAI;AAC1B,MAAI,CAAC,SAAS,CAAC,MAAM,KAAK,GAAG;AAC3B,WAAO,KAAK,YAAY,cAAc,sDAAsD,CAAC;AAC7F,UAAMC,YAAW,eAAqC,EAAE,MAAM,WAAW,OAAO,EAAE,SAAS,MAAM,QAAQ,MAAM,QAAQ,OAAO,OAAO,GAAG,QAAQ,aAAa,YAAY,SAAS,GAAG,UAAU,QAAQ,eAAe,MAAM,CAAC,EAAe,CAAC;AAC7O,qBAAiBA,WAAU,MAAM;AAAA,EACnC;AAEA,QAAM,WAAW,iBAAiB,KAAK,GAAG,KAAK,iBAAiB,KAAK,CAAC;AACtE,MAAI,UAAU,iBAAiB,KAAK,UAAU,CAAC,KAAK;AACpD,MAAI,SAAS,aAAa,iBAAiB,KAAK,SAAS,CAAC,CAAC;AAC3D,MAAI,UAAU;AACZ,UAAM,SAAS,cAAc,QAAQ;AACrC,cAAU,WAAW,OAAO,WAAW;AACvC,aAAS,UAAU,OAAO;AAAA,EAC5B;AAEA,MAAI,CAAC,QAAS,QAAO,KAAK,YAAY,iBAAiB,2DAA2D,CAAC;AACnH,MAAI,CAAC,OAAQ,QAAO,KAAK,YAAY,iBAAiB,sEAAsE,CAAC;AAE7H,MAAI,SAAS,OAAO,KAAK,UAAU,KAAK,EAAE,YAAY;AACtD,MAAI,CAAC,kBAAkB,SAAS,MAAM,GAAG;AAAE,aAAS,KAAK,uBAAuB,MAAM,yBAAyB;AAAG,aAAS;AAAA,EAAM;AACjI,MAAI,WAAW,OAAQ,UAAS;AAEhC,QAAM,aAAa,OAAO,KAAK,SAAS,CAAC;AACzC,QAAM,QAAQ,OAAO,SAAS,UAAU,IAAI,KAAK,IAAI,KAAK,IAAI,YAAY,IAAI,GAAG,CAAC,IAAI;AAEtF,QAAM,cAAc,OAAO,KAAK,UAAU,WAAW,EAAE,YAAY;AACnE,QAAM,SAAS,CAAC,aAAa,SAAS,MAAM,EAAE,SAAS,WAAW,IAAI,cAAc;AACpF,QAAM,oBAAoB,WAAW;AAErC,QAAM,kBAAkB,OAAO,KAAK,cAAc,QAAQ,EAAE,YAAY;AACxE,MAAI;AACJ,MAAI,oBAAoB,cAAe,mBAAkB;AAAA,WAChD,mBAAmB,KAAK,eAAe,GAAG;AAAE,UAAM,QAAQ,gBAAgB,YAAY;AAAG,sBAAkB,MAAM,UAAU,IAAI,MAAM,MAAM,GAAG,CAAC,EAAE,OAAO,GAAG,GAAG,IAAI;AAAA,EAAU,WAC5K,gBAAgB,WAAW,GAAG,EAAG,mBAAkB,gBAAgB,QAAQ,KAAK,EAAE,EAAE,MAAM,GAAG,CAAC,EAAE,OAAO,GAAG,GAAG;AAEtH,QAAM,QAAmB,EAAE,SAAS,WAAW,MAAM,QAAQ,UAAU,MAAM,QAAQ,OAAO,QAAQ,YAAY,gBAAgB;AAChI,MAAI,OAAO,QAAQ;AAAE,UAAMA,YAAW,eAAqC,EAAE,MAAM,WAAW,OAAO,UAAU,QAAQ,MAAM,CAAC,GAAgB,cAAc,CAAC;AAAG,qBAAiBA,WAAU,MAAM;AAAA,EAAE;AAEnM,QAAM,kBAAkB;AACxB,QAAM,iBAAiB;AAEvB,MAAI,wBAAwB,cAAc,KAAK,MAAM,WAAW,KAAK,KAAK,OAAO;AACjF,QAAM,gBAAgB,MAAM,aAAkC;AAAA,IAC5D,MAAM,cAAc,eAAe;AAAA,IACnC;AAAA,IACA,cAAc,EAAE,KAAK,gBAAgB,QAAQ,OAAO,qBAAqB,oBAAoB,SAAS,QAAW,YAAY,gBAAgB;AAAA,EAC/I,CAAC;AAED,MAAI,CAAC,cAAc,IAAI;AACrB,WAAO,KAAK,cAAc,SAAS,YAAY,YAAY,iCAAiC,CAAC;AAC7F,UAAMA,YAAW,eAAqC,EAAE,MAAM,WAAW,OAAO,UAAU,QAAQ,WAAW,cAAc,aAAa,QAAW,MAAM,CAAC,GAAgB,cAAc,CAAC;AACzL,qBAAiBA,WAAU,MAAM;AAAA,EACnC;AAEA,QAAM,WAAW,cAAc,MAAM,SAAS,cAAc;AAC5D,MAAI,CAAC,UAAU;AACb,WAAO,KAAK,YAAY,mBAAmB,2DAA2D,CAAC;AACvG,UAAMA,YAAW,eAAqC,EAAE,MAAM,WAAW,OAAO,UAAU,QAAQ,WAAW,cAAc,aAAa,QAAW,MAAM,CAAC,GAAgB,cAAc,CAAC;AACzL,qBAAiBA,WAAU,MAAM;AAAA,EACnC;AAEA,MAAI,qBAAqB,OAAO;AAChC,MAAI,SAAwB;AAC5B,MAAI,cAA6B;AACjC,MAAI;AACF,UAAM,MAAM,MAAM,MAAM,QAAQ;AAChC,QAAI,CAAC,IAAI,GAAI,QAAO,KAAK,YAAY,WAAW,oCAAoC,IAAI,MAAM,IAAI,CAAC;AAAA,SAC9F;AAAE,oBAAc,IAAI,QAAQ,IAAI,cAAc;AAAG,eAAU,WAAW,QAAS,OAAO,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,OAAO,KAAK,MAAM,IAAI,YAAY,CAAC;AAAA,IAAE;AAAA,EAC3J,SAAS,OAAO;AACd,UAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU;AACzD,WAAO,KAAK,YAAY,WAAW,6BAA6B,OAAO,EAAE,CAAC;AAAA,EAC5E;AAEA,MAAI,CAAC,UAAU,OAAO,QAAQ;AAC5B,UAAMA,YAAW,eAAqC,EAAE,MAAM,WAAW,OAAO,UAAU,QAAQ,WAAW,cAAc,aAAa,QAAW,MAAM,CAAC,GAAgB,cAAc,CAAC;AACzL,qBAAiBA,WAAU,MAAM;AAAA,EACnC;AAEA,QAAM,kBAAkB,eAAe,QAAQ,mBAAmB,GAAG;AACrE,QAAM,UAAU,KAAK,QAAQ,gBAAgB,eAAe;AAC5D,QAAM,gBAAgB,OAAO;AAC7B,QAAM,YAAY,WAAW,QAAQ,QAAQ;AAC7C,QAAM,WAAW,KAAK,KAAK,SAAS,GAAG,eAAe,IAAI,SAAS,EAAE;AACrE,QAAM,UAAU,UAAU,MAAM;AAEhC,QAAM,OAAuB;AAAA,IAC3B,MAAM,EAAE,KAAK,iBAAiB,QAAQ,eAAe;AAAA,IACrD,YAAY,EAAE,MAAM,UAAU,KAAK,UAAU,QAAQ,WAAW,OAAO,QAAQ,YAAY,iBAAiB,YAAY;AAAA,EAC1H;AAEA,QAAM,WAAW,eAA0C,EAAE,MAAM,WAAW,OAAO,MAAM,UAAU,QAAQ,WAAW,cAAc,aAAa,QAAW,cAAc,CAAC;AAC7K,UAAQ,OAAO,MAAM,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,CAAI;AAC7D,UAAQ,KAAK,YAAY,MAAM,CAAC;AAClC;AAEA,KAAK,EAAE,MAAM,CAAC,UAAmB;AAC/B,QAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU;AACzD,QAAM,WAAW,eAAqC,EAAE,MAAM,WAAW,OAAO,EAAE,SAAS,MAAM,QAAQ,MAAM,QAAQ,OAAO,OAAO,GAAG,QAAQ,aAAa,YAAY,SAAS,GAAG,QAAQ,CAAC,YAAY,YAAY,SAAS,EAAE,OAAO,iBAAiB,QAAQ,MAAM,QAAQ,OAAU,CAAC,CAAC,GAAG,MAAM,CAAC,EAAe,CAAC;AACrT,UAAQ,OAAO,MAAM,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,CAAI;AAC7D,UAAQ,KAAK,CAAC;AAChB,CAAC;",
  "names": ["path", "envelope"]
}
 diff --git a/use-figma/scripts/get-variable-definitions.mjs b/use-figma/scripts/get-variable-definitions.mjs new file mode 100755 index 0000000..d4fa4f4 --- /dev/null +++ b/use-figma/scripts/get-variable-definitions.mjs @@ -0,0 +1,404 @@ +#!/usr/bin/env node + +// coding-tools/figma-tools/js/src/_utils/cli-args.ts +function parseArgs(argv = process.argv.slice(2)) { + const args = { _: [] }; + for (let i = 0; i < argv.length; i += 1) { + const arg = argv[i]; + if (!arg.startsWith("-") || arg === "-") { + args._.push(arg); + continue; + } + if (arg === "--") { + const remaining = argv.slice(i + 1); + args._.push(...remaining); + break; + } + const [rawKey, inlineValue] = arg.split("=", 2); + const normalisedKey = rawKey.replace(/^-+/, ""); + let value; + if (inlineValue !== void 0) { + value = inlineValue; + } else { + const next = argv[i + 1]; + if (next !== void 0 && !next.startsWith("-")) { + value = next; + i += 1; + } else { + value = true; + } + } + args[normalisedKey] = value; + } + return args; +} + +// coding-tools/figma-tools/js/src/_utils/url-parse.ts +var FILE_KEY_REGEX = /figma\.com\/(?:file|design)\/([A-Za-z0-9]+)\//i; +function parseFigmaUrl(input) { + if (!input) return { fileKey: null, nodeId: null }; + try { + const url = new URL(input); + const match = url.href.match(FILE_KEY_REGEX); + const fileKey = match ? match[1] : null; + const nodeParam = url.searchParams.get("node-id"); + const nodeId = nodeParam ? ensureNodeId(nodeParam) : null; + return { fileKey, nodeId }; + } catch { + return { fileKey: null, nodeId: null }; + } +} +function ensureNodeId(value) { + if (!value) return null; + const decoded = decodeURIComponent(value); + if (decoded.includes(":")) return decoded; + if (/^[0-9]+-[0-9]+$/.test(decoded)) { + const [left, right] = decoded.split("-", 2); + return `${left}:${right}`; + } + return decoded; +} + +// coding-tools/figma-tools/js/src/_utils/config.ts +var config_default = { + schemaVersion: "1.0.0", + source: "agentic-coding-templates/figma-tools", + http: { + maxAttempts: 5, + initialDelayMs: 250 + } +}; + +// coding-tools/figma-tools/js/src/_utils/envelope.ts +function buildRateLimitMeta(rateLimit = {}) { + return { + remaining: rateLimit.remaining ?? null, + resetAt: rateLimit.resetAt ?? null, + attempts: rateLimit.attempts ?? 1, + lastWaitMs: rateLimit.lastWaitMs ?? 0 + }; +} +function createEnvelope({ + tool, + input = {}, + data = {}, + warnings = [], + errors = [], + rateLimit, + schemaVersion +}) { + return { + schemaVersion: schemaVersion ?? config_default.schemaVersion, + tool, + input, + meta: { + generatedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: config_default.source, + rateLimit: buildRateLimitMeta(rateLimit) + }, + data, + warnings, + errors + }; +} + +// coding-tools/figma-tools/js/src/_utils/errors.ts +var ERROR_EXIT_CODES = { + INPUT_INVALID: 1, + CONFIG_INVALID: 1, + FIGMA_AUTH: 1, + FIGMA_NOT_FOUND: 2, + FIGMA_RATE_LIMIT: 2, + NETWORK: 2, + INTERNAL: 3 +}; +function createError(code, message, detail) { + return { + code, + message, + detail: detail ?? null + }; +} +function getExitCode(errors = []) { + if (!errors.length) { + return 0; + } + return errors.reduce((max, error) => { + const exitCode = ERROR_EXIT_CODES[error.code] ?? 1; + return Math.max(max, exitCode); + }, 0); +} + +// coding-tools/figma-tools/js/src/_utils/http-client.ts +var BASE_URL = "https://api.figma.com"; +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} +function parseJsonSafely(text) { + try { + return text ? JSON.parse(text) : {}; + } catch { + return { raw: text }; + } +} +function parseRateLimit(headers, attempts, lastWaitMs) { + const remainingHeader = headers.get("x-ratelimit-remaining"); + const resetHeader = headers.get("x-ratelimit-reset"); + let remaining = null; + if (remainingHeader !== null && remainingHeader !== void 0) { + const parsed = Number(remainingHeader); + remaining = Number.isNaN(parsed) ? null : parsed; + } + let resetAt = null; + if (resetHeader) { + const numericReset = Number(resetHeader); + if (!Number.isNaN(numericReset)) { + resetAt = new Date(numericReset * 1e3).toISOString(); + } else { + const date = new Date(resetHeader); + if (!Number.isNaN(date.valueOf())) { + resetAt = date.toISOString(); + } + } + } + return { + remaining, + resetAt, + attempts, + lastWaitMs + }; +} +function computeBackoffMs(attempt, initialDelayMs) { + return initialDelayMs * 2 ** (attempt - 1); +} +async function figmaRequest(options) { + const { + path, + method = "GET", + token, + headers = {}, + body, + searchParams, + maxAttempts = config_default.http?.maxAttempts ?? 5, + initialDelayMs = config_default.http?.initialDelayMs ?? 250 + } = options; + if (!token) { + return { + ok: false, + error: createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is missing from the environment."), + status: null, + rateLimit: null + }; + } + const url = new URL(path, BASE_URL); + if (searchParams) { + Object.entries(searchParams).forEach(([key, value]) => { + if (value === void 0 || value === null) return; + url.searchParams.append(key, String(value)); + }); + } + let attempt = 0; + let lastWaitMs = 0; + while (attempt < maxAttempts) { + attempt += 1; + const response = await fetch(url, { + method, + headers: { + "Content-Type": "application/json", + "X-Figma-Token": token, + ...headers + }, + body: body ? JSON.stringify(body) : void 0 + }); + const text = await response.text(); + const payload = parseJsonSafely(text); + const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs); + if (response.ok) { + return { ok: true, data: payload, rateLimit }; + } + const status = response.status; + if (status === 401 || status === 403) { + return { ok: false, error: createError("FIGMA_AUTH", payload?.message ?? "Figma token is unauthorized.", { status }), status, rateLimit }; + } + if (status === 404) { + return { ok: false, error: createError("FIGMA_NOT_FOUND", payload?.message ?? "Resource not found.", { status }), status, rateLimit }; + } + if (status === 429 || status >= 500) { + if (attempt >= maxAttempts) { + return { + ok: false, + error: createError(status === 429 ? "FIGMA_RATE_LIMIT" : "NETWORK", payload?.message ?? "Figma request failed after maximum retries.", { status }), + status, + rateLimit + }; + } + let waitMs = computeBackoffMs(attempt, initialDelayMs); + const resetHeader = response.headers.get("x-ratelimit-reset"); + if (resetHeader) { + const asNumber = Number(resetHeader); + if (!Number.isNaN(asNumber)) { + const resetMs = asNumber * 1e3; + const delta = resetMs - Date.now(); + if (delta > 0) waitMs = Math.max(waitMs, delta); + } + } + const jitter = Math.floor(Math.random() * 100); + lastWaitMs = waitMs + jitter; + await sleep(lastWaitMs); + continue; + } + return { ok: false, error: createError("INTERNAL", payload?.message ?? "Unexpected error from Figma API.", { status }), status, rateLimit }; + } + return { + ok: false, + error: createError("NETWORK", "Unable to reach Figma API."), + status: null, + rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs } + }; +} + +// coding-tools/figma-tools/js/src/get-variable-definitions.ts +var TOOL_NAME = "get-variable-definitions"; +function log(message, verbose) { + if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message} +`); +} +function toOptionalString(value) { + return typeof value === "string" && value.length > 0 ? value : null; +} +function exitWithEnvelope(envelope, errors = []) { + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +function resolveCollectionName(id, collections) { + if (!id) return null; + const entry = collections.find((c) => c.id === id); + return entry?.name ?? null; +} +function buildVariableEntry(variable, collections, sets) { + return { + id: variable.id, + name: variable.name, + key: variable.key, + resolvedType: variable.resolvedType, + collectionId: variable.collectionId ?? variable.variableCollectionId ?? null, + collectionName: resolveCollectionName(variable.collectionId ?? variable.variableCollectionId, collections), + variableSetId: variable.variableSetId ?? null, + variableSetName: resolveCollectionName(variable.variableSetId, sets), + scopes: variable.scopes ?? [], + description: variable.description ?? null, + defaultValue: variable.valuesByMode?.[variable.defaultModeId ?? ""] ?? null, + valuesByMode: variable.valuesByMode ?? {} + }; +} +function partitionVariables(list) { + const colors = []; + const spacing = []; + const typography = []; + const others = []; + for (const entry of list) { + switch (entry.resolvedType) { + case "COLOR": + colors.push(entry); + break; + case "FLOAT": + spacing.push(entry); + break; + case "STRING": + case "BOOLEAN": + typography.push(entry); + break; + default: + others.push(entry); + } + } + return { colors, spacing, typography, others }; +} +function extractStyles(payload) { + if (!payload) return []; + if (Array.isArray(payload.styles)) return payload.styles; + if (payload.meta?.styles) return Object.values(payload.meta.styles); + return []; +} +async function main() { + const args = parseArgs(); + const verbose = Boolean(args.verbose ?? args.v); + const schemaVersion = toOptionalString(args["schema-version"]) ?? void 0; + const warnings = []; + const errors = []; + const token = process.env.FIGMA_ACCESS_TOKEN; + if (!token || !token.trim()) { + errors.push(createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is required but was not provided.")); + const envelope2 = createEnvelope({ + tool: TOOL_NAME, + input: { fileKey: null, includeStyles: false }, + warnings, + errors, + schemaVersion, + data: {} + }); + exitWithEnvelope(envelope2, errors); + } + const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u); + let fileKey = toOptionalString(args["file-key"]) ?? void 0; + if (urlInput) { + const parsed = parseFigmaUrl(urlInput); + fileKey = fileKey || parsed.fileKey || void 0; + } + const includeStyles = args["include-styles"] !== "false"; + const input = { fileKey: fileKey ?? null, includeStyles }; + if (!fileKey) { + errors.push(createError("INPUT_INVALID", "A valid Figma file key is required (--file-key or --url).")); + } + if (errors.length) { + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, data: {}, schemaVersion }); + exitWithEnvelope(envelope2, errors); + } + const resolvedFileKey = fileKey; + log("Fetching variables", verbose); + const variablesResponse = await figmaRequest({ + path: `/v1/files/${resolvedFileKey}/variables/local`, + token + }); + let stylesResponse; + if (includeStyles) { + log("Fetching styles", verbose); + stylesResponse = await figmaRequest({ path: `/v1/files/${resolvedFileKey}/styles`, token }); + } else { + stylesResponse = { ok: true, data: { styles: [] }, rateLimit: null }; + } + if (!variablesResponse.ok) { + errors.push(variablesResponse.error ?? createError("INTERNAL", "Failed to fetch variables.")); + const envelope2 = createEnvelope({ tool: TOOL_NAME, input, warnings, errors, rateLimit: variablesResponse.rateLimit ?? void 0, schemaVersion, data: {} }); + exitWithEnvelope(envelope2, errors); + } + if (!stylesResponse.ok) { + warnings.push(stylesResponse.error?.message ?? "Failed to fetch styles."); + } + const variablesPayload = variablesResponse.data ?? {}; + const variableCollections = variablesPayload.collections ?? []; + const variableSets = variablesPayload.variableCollections ?? []; + const variables = variablesPayload.variables ?? []; + const normalisedVariables = variables.map((v) => buildVariableEntry(v, variableCollections, variableSets)); + const partitions = partitionVariables(normalisedVariables); + const styles = stylesResponse.ok ? extractStyles(stylesResponse.data) : []; + const data = { + file: { key: resolvedFileKey }, + variables: partitions, + rawVariables: normalisedVariables, + styles + }; + const envelope = createEnvelope({ tool: TOOL_NAME, input, data, warnings, errors, rateLimit: variablesResponse.rateLimit ?? void 0, schemaVersion }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); +} +main().catch((error) => { + const message = error instanceof Error ? error.message : "Unknown error"; + const envelope = createEnvelope({ tool: TOOL_NAME, input: { fileKey: null, includeStyles: false }, errors: [createError("INTERNAL", message, { stack: error instanceof Error ? error.stack : void 0 })], data: {} }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(3); +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/_utils/cli-args.ts", "../src/_utils/url-parse.ts", "../src/_utils/config.ts", "../src/_utils/envelope.ts", "../src/_utils/errors.ts", "../src/_utils/http-client.ts", "../src/get-variable-definitions.ts"],
  "sourcesContent": ["export type CliArgValue = string | boolean;\n\nexport interface CliArgs {\n  _: string[];\n  [key: string]: CliArgValue | string[];\n}\n\nexport function parseArgs(argv: string[] = process.argv.slice(2)): CliArgs {\n  const args: CliArgs = { _: [] };\n\n  for (let i = 0; i < argv.length; i += 1) {\n    const arg = argv[i];\n\n    if (!arg.startsWith('-') || arg === '-') {\n      args._.push(arg);\n      continue;\n    }\n\n    if (arg === '--') {\n      const remaining = argv.slice(i + 1);\n      args._.push(...remaining);\n      break;\n    }\n\n    const [rawKey, inlineValue] = arg.split('=', 2);\n    const normalisedKey = rawKey.replace(/^-+/, '');\n\n    let value: CliArgValue;\n    if (inlineValue !== undefined) {\n      value = inlineValue;\n    } else {\n      const next = argv[i + 1];\n      if (next !== undefined && !next.startsWith('-')) {\n        value = next;\n        i += 1;\n      } else {\n        value = true;\n      }\n    }\n\n    args[normalisedKey] = value;\n  }\n\n  return args;\n}\n\n", "const FILE_KEY_REGEX = /figma\\.com\\/(?:file|design)\\/([A-Za-z0-9]+)\\//i;\n\nexport interface ParsedFigmaUrl {\n  fileKey: string | null;\n  nodeId: string | null;\n}\n\nexport function parseFigmaUrl(input: string | null | undefined): ParsedFigmaUrl {\n  if (!input) return { fileKey: null, nodeId: null };\n  try {\n    const url = new URL(input);\n    const match = url.href.match(FILE_KEY_REGEX);\n    const fileKey = match ? match[1] : null;\n    const nodeParam = url.searchParams.get('node-id');\n    const nodeId = nodeParam ? ensureNodeId(nodeParam) : null;\n    return { fileKey, nodeId };\n  } catch {\n    return { fileKey: null, nodeId: null };\n  }\n}\n\nexport function ensureNodeId(value: string | null | undefined): string | null {\n  if (!value) return null;\n  const decoded = decodeURIComponent(value);\n  if (decoded.includes(':')) return decoded;\n  if (/^[0-9]+-[0-9]+$/.test(decoded)) {\n    const [left, right] = decoded.split('-', 2);\n    return `${left}:${right}`;\n  }\n  return decoded;\n}\n\n", "export default {\n  schemaVersion: '1.0.0',\n  source: 'agentic-coding-templates/figma-tools',\n  http: {\n    maxAttempts: 5,\n    initialDelayMs: 250,\n  },\n} as const;\n\n", "import config from './config.ts';\nimport type { ToolError } from './errors.ts';\n\nexport interface RateLimitMeta {\n  remaining: number | null;\n  resetAt: string | null;\n  attempts: number;\n  lastWaitMs: number;\n}\n\nexport interface ToolEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  schemaVersion: string;\n  tool: string;\n  input: TInput;\n  meta: {\n    generatedAt: string;\n    source: string;\n    rateLimit: RateLimitMeta;\n  };\n  data: TData;\n  warnings: string[];\n  errors: ToolError[];\n}\n\nexport interface CreateEnvelopeOptions<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  tool: string;\n  input?: TInput;\n  data?: TData;\n  warnings?: string[];\n  errors?: ToolError[];\n  rateLimit?: Partial<RateLimitMeta>;\n  schemaVersion?: string;\n}\n\nfunction buildRateLimitMeta(rateLimit: Partial<RateLimitMeta> = {}): RateLimitMeta {\n  return {\n    remaining: rateLimit.remaining ?? null,\n    resetAt: rateLimit.resetAt ?? null,\n    attempts: rateLimit.attempts ?? 1,\n    lastWaitMs: rateLimit.lastWaitMs ?? 0,\n  };\n}\n\nexport function createEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n>({\n  tool,\n  input = {} as TInput,\n  data = {} as TData,\n  warnings = [],\n  errors = [],\n  rateLimit,\n  schemaVersion,\n}: CreateEnvelopeOptions<TInput, TData>): ToolEnvelope<TInput, TData> {\n  return {\n    schemaVersion: schemaVersion ?? config.schemaVersion,\n    tool,\n    input,\n    meta: {\n      generatedAt: new Date().toISOString(),\n      source: config.source,\n      rateLimit: buildRateLimitMeta(rateLimit),\n    },\n    data,\n    warnings,\n    errors,\n  };\n}\n\n", "export const ERROR_EXIT_CODES = {\n  INPUT_INVALID: 1,\n  CONFIG_INVALID: 1,\n  FIGMA_AUTH: 1,\n  FIGMA_NOT_FOUND: 2,\n  FIGMA_RATE_LIMIT: 2,\n  NETWORK: 2,\n  INTERNAL: 3,\n} as const;\n\nexport type ErrorCode = keyof typeof ERROR_EXIT_CODES;\n\nexport interface ToolError<TDetail = unknown> {\n  code: ErrorCode | string;\n  message: string;\n  detail?: TDetail | null;\n}\n\nexport function createError<TDetail = unknown>(\n  code: ErrorCode | string,\n  message: string,\n  detail?: TDetail | null\n): ToolError<TDetail> {\n  return {\n    code,\n    message,\n    detail: detail ?? null,\n  };\n}\n\nexport function getExitCode(errors: ToolError[] = []): number {\n  if (!errors.length) {\n    return 0;\n  }\n\n  return errors.reduce((max, error) => {\n    const exitCode = ERROR_EXIT_CODES[error.code as ErrorCode] ?? 1;\n    return Math.max(max, exitCode);\n  }, 0);\n}\n\n", "import config from './config.ts';\nimport { createError } from './errors.ts';\nimport type { ToolError } from './errors.ts';\nimport type { RateLimitMeta } from './envelope.ts';\n\nconst BASE_URL = 'https://api.figma.com';\n\ntype SearchParams = Record<string, string | number | boolean | null | undefined>;\n\ninterface FigmaRequestOptions {\n  path: string;\n  method?: string;\n  token?: string;\n  headers?: Record<string, string>;\n  body?: unknown;\n  searchParams?: SearchParams;\n  maxAttempts?: number;\n  initialDelayMs?: number;\n}\n\ninterface FigmaSuccess<TData> {\n  ok: true;\n  data: TData;\n  rateLimit: RateLimitMeta;\n}\n\ninterface FigmaFailure {\n  ok: false;\n  error: ToolError<{ status?: number }>;\n  status?: number | null;\n  rateLimit: RateLimitMeta | null;\n}\n\nexport type FigmaResponse<TData> = FigmaSuccess<TData> | FigmaFailure;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction parseJsonSafely(text: string): unknown {\n  try {\n    return text ? JSON.parse(text) : {};\n  } catch {\n    return { raw: text };\n  }\n}\n\nfunction parseRateLimit(headers: Headers, attempts: number, lastWaitMs: number): RateLimitMeta {\n  const remainingHeader = headers.get('x-ratelimit-remaining');\n  const resetHeader = headers.get('x-ratelimit-reset');\n\n  let remaining: number | null = null;\n  if (remainingHeader !== null && remainingHeader !== undefined) {\n    const parsed = Number(remainingHeader);\n    remaining = Number.isNaN(parsed) ? null : parsed;\n  }\n\n  let resetAt: string | null = null;\n  if (resetHeader) {\n    const numericReset = Number(resetHeader);\n    if (!Number.isNaN(numericReset)) {\n      resetAt = new Date(numericReset * 1000).toISOString();\n    } else {\n      const date = new Date(resetHeader);\n      if (!Number.isNaN(date.valueOf())) {\n        resetAt = date.toISOString();\n      }\n    }\n  }\n\n  return {\n    remaining,\n    resetAt,\n    attempts,\n    lastWaitMs,\n  };\n}\n\nfunction computeBackoffMs(attempt: number, initialDelayMs: number): number {\n  return initialDelayMs * 2 ** (attempt - 1);\n}\n\nexport async function figmaRequest<TData = unknown>(\n  options: FigmaRequestOptions\n): Promise<FigmaResponse<TData>> {\n  const {\n    path,\n    method = 'GET',\n    token,\n    headers = {},\n    body,\n    searchParams,\n    maxAttempts = config.http?.maxAttempts ?? 5,\n    initialDelayMs = config.http?.initialDelayMs ?? 250,\n  } = options;\n\n  if (!token) {\n    return {\n      ok: false,\n      error: createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is missing from the environment.'),\n      status: null,\n      rateLimit: null,\n    };\n  }\n\n  const url = new URL(path, BASE_URL);\n\n  if (searchParams) {\n    Object.entries(searchParams).forEach(([key, value]) => {\n      if (value === undefined || value === null) return;\n      url.searchParams.append(key, String(value));\n    });\n  }\n\n  let attempt = 0;\n  let lastWaitMs = 0;\n\n  while (attempt < maxAttempts) {\n    attempt += 1;\n\n    const response = await fetch(url, {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        'X-Figma-Token': token,\n        ...headers,\n      },\n      body: body ? JSON.stringify(body) : undefined,\n    });\n\n    const text = await response.text();\n    const payload = parseJsonSafely(text) as { message?: string };\n    const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs);\n\n    if (response.ok) {\n      return { ok: true, data: payload as TData, rateLimit };\n    }\n\n    const status = response.status;\n\n    if (status === 401 || status === 403) {\n      return { ok: false, error: createError('FIGMA_AUTH', payload?.message ?? 'Figma token is unauthorized.', { status }), status, rateLimit };\n    }\n\n    if (status === 404) {\n      return { ok: false, error: createError('FIGMA_NOT_FOUND', payload?.message ?? 'Resource not found.', { status }), status, rateLimit };\n    }\n\n    if (status === 429 || status >= 500) {\n      if (attempt >= maxAttempts) {\n        return {\n          ok: false,\n          error: createError(status === 429 ? 'FIGMA_RATE_LIMIT' : 'NETWORK', payload?.message ?? 'Figma request failed after maximum retries.', { status }),\n          status,\n          rateLimit,\n        };\n      }\n\n      let waitMs = computeBackoffMs(attempt, initialDelayMs);\n      const resetHeader = response.headers.get('x-ratelimit-reset');\n      if (resetHeader) {\n        const asNumber = Number(resetHeader);\n        if (!Number.isNaN(asNumber)) {\n          const resetMs = asNumber * 1000;\n          const delta = resetMs - Date.now();\n          if (delta > 0) waitMs = Math.max(waitMs, delta);\n        }\n      }\n\n      const jitter = Math.floor(Math.random() * 100);\n      lastWaitMs = waitMs + jitter;\n      await sleep(lastWaitMs);\n      continue;\n    }\n\n    return { ok: false, error: createError('INTERNAL', payload?.message ?? 'Unexpected error from Figma API.', { status }), status, rateLimit };\n  }\n\n  return {\n    ok: false,\n    error: createError('NETWORK', 'Unable to reach Figma API.'),\n    status: null,\n    rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs },\n  };\n}\n\n", "#!/usr/bin/env node\n\nimport { parseArgs, type CliArgs } from './_utils/cli-args.ts'\nimport { parseFigmaUrl } from './_utils/url-parse.ts'\nimport { createEnvelope, type ToolEnvelope } from './_utils/envelope.ts'\nimport { createError, getExitCode, type ToolError } from './_utils/errors.ts'\nimport { figmaRequest } from './_utils/http-client.ts'\n\nconst TOOL_NAME = 'get-variable-definitions'\ntype EmptyData = Record<string, never>\n\ninterface ToolInput extends Record<string, unknown> {\n  fileKey: string | null\n  includeStyles: boolean\n}\n\ninterface VariableMode { modeId: string; name: string }\n\ninterface VariablePayloadEntry {\n  id: string\n  name: string\n  key?: string\n  resolvedType?: string\n  collectionId?: string\n  variableCollectionId?: string\n  variableSetId?: string\n  variableCollection?: string\n  variableSet?: string\n  scopes?: string[]\n  description?: string\n  defaultModeId?: string\n  valuesByMode?: Record<string, unknown>\n  modes?: VariableMode[]\n}\n\ninterface VariableCollectionMeta { id: string; name?: string }\n\ninterface VariablesResponsePayload {\n  collections?: VariableCollectionMeta[]\n  variableCollections?: VariableCollectionMeta[]\n  variables?: VariablePayloadEntry[]\n}\n\ninterface StylesResponsePayload { meta?: { styles?: Record<string, FigmaStyle> }; styles?: FigmaStyle[] }\ninterface FigmaStyle { key?: string; name?: string; style_type?: string; description?: string }\n\ninterface VariableEntry {\n  id: string\n  name: string\n  key?: string\n  resolvedType?: string\n  collectionId: string | null\n  collectionName: string | null\n  variableSetId: string | null\n  variableSetName: string | null\n  scopes: string[]\n  description: string | null\n  defaultValue: unknown\n  valuesByMode: Record<string, unknown>\n}\n\ninterface PartitionedVariables {\n  colors: VariableEntry[]\n  spacing: VariableEntry[]\n  typography: VariableEntry[]\n  others: VariableEntry[]\n}\n\ninterface VariableData {\n  file: { key: string }\n  variables: PartitionedVariables\n  rawVariables: VariableEntry[]\n  styles: FigmaStyle[]\n}\n\nfunction log(message: string, verbose: boolean): void {\n  if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message}\\n`)\n}\n\nfunction toOptionalString(value: CliArgs[string]): string | null {\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nfunction exitWithEnvelope(\n  envelope: ToolEnvelope<ToolInput, VariableData | EmptyData>,\n  errors: ToolError[] = []\n): never {\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nfunction resolveCollectionName(id: string | undefined, collections: VariableCollectionMeta[]): string | null {\n  if (!id) return null\n  const entry = collections.find((c) => c.id === id)\n  return entry?.name ?? null\n}\n\nfunction buildVariableEntry(\n  variable: VariablePayloadEntry,\n  collections: VariableCollectionMeta[],\n  sets: VariableCollectionMeta[]\n): VariableEntry {\n  return {\n    id: variable.id,\n    name: variable.name,\n    key: variable.key,\n    resolvedType: variable.resolvedType,\n    collectionId: variable.collectionId ?? variable.variableCollectionId ?? null,\n    collectionName:\n      resolveCollectionName(variable.collectionId ?? variable.variableCollectionId, collections),\n    variableSetId: variable.variableSetId ?? null,\n    variableSetName: resolveCollectionName(variable.variableSetId, sets),\n    scopes: variable.scopes ?? [],\n    description: variable.description ?? null,\n    defaultValue: variable.valuesByMode?.[variable.defaultModeId ?? ''] ?? null,\n    valuesByMode: variable.valuesByMode ?? {},\n  }\n}\n\nfunction partitionVariables(list: VariableEntry[]): PartitionedVariables {\n  const colors: VariableEntry[] = []\n  const spacing: VariableEntry[] = []\n  const typography: VariableEntry[] = []\n  const others: VariableEntry[] = []\n  for (const entry of list) {\n    switch (entry.resolvedType) {\n      case 'COLOR':\n        colors.push(entry)\n        break\n      case 'FLOAT':\n        spacing.push(entry)\n        break\n      case 'STRING':\n      case 'BOOLEAN':\n        typography.push(entry)\n        break\n      default:\n        others.push(entry)\n    }\n  }\n  return { colors, spacing, typography, others }\n}\n\nfunction extractStyles(payload: StylesResponsePayload | null | undefined): FigmaStyle[] {\n  if (!payload) return []\n  if (Array.isArray(payload.styles)) return payload.styles\n  if (payload.meta?.styles) return Object.values(payload.meta.styles)\n  return []\n}\n\nasync function main(): Promise<void> {\n  const args = parseArgs()\n  const verbose = Boolean(args.verbose ?? args.v)\n  const schemaVersion = toOptionalString(args['schema-version']) ?? undefined\n\n  const warnings: string[] = []\n  const errors: ToolError[] = []\n\n  const token = process.env.FIGMA_ACCESS_TOKEN\n  if (!token || !token.trim()) {\n    errors.push(createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is required but was not provided.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({\n      tool: TOOL_NAME,\n      input: { fileKey: null, includeStyles: false },\n      warnings,\n      errors,\n      schemaVersion,\n      data: {} as EmptyData,\n    })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const urlInput = toOptionalString(args.url) ?? toOptionalString(args.u)\n  let fileKey = toOptionalString(args['file-key']) ?? undefined\n  if (urlInput) {\n    const parsed = parseFigmaUrl(urlInput)\n    fileKey = fileKey || parsed.fileKey || undefined\n  }\n\n  const includeStyles = args['include-styles'] !== 'false'\n\n  const input: ToolInput = { fileKey: fileKey ?? null, includeStyles }\n\n  if (!fileKey) {\n    errors.push(createError('INPUT_INVALID', 'A valid Figma file key is required (--file-key or --url).'))\n  }\n  if (errors.length) {\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, data: {} as EmptyData, schemaVersion })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  const resolvedFileKey = fileKey as string\n\n  log('Fetching variables', verbose)\n  const variablesResponse = await figmaRequest<VariablesResponsePayload>({\n    path: `/v1/files/${resolvedFileKey}/variables/local`,\n    token,\n  })\n\n  let stylesResponse:\n    | Awaited<ReturnType<typeof figmaRequest<StylesResponsePayload>>>\n    | { ok: true; data: StylesResponsePayload; rateLimit: null }\n\n  if (includeStyles) {\n    log('Fetching styles', verbose)\n    stylesResponse = await figmaRequest<StylesResponsePayload>({ path: `/v1/files/${resolvedFileKey}/styles`, token })\n  } else {\n    stylesResponse = { ok: true, data: { styles: [] }, rateLimit: null }\n  }\n\n  if (!variablesResponse.ok) {\n    errors.push(variablesResponse.error ?? createError('INTERNAL', 'Failed to fetch variables.'))\n    const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input, warnings, errors, rateLimit: variablesResponse.rateLimit ?? undefined, schemaVersion, data: {} as EmptyData })\n    exitWithEnvelope(envelope, errors)\n  }\n\n  if (!stylesResponse.ok) {\n    warnings.push(stylesResponse.error?.message ?? 'Failed to fetch styles.')\n  }\n\n  const variablesPayload = variablesResponse.data ?? {}\n  const variableCollections = variablesPayload.collections ?? []\n  const variableSets = variablesPayload.variableCollections ?? []\n  const variables = variablesPayload.variables ?? []\n\n  const normalisedVariables = variables.map((v) => buildVariableEntry(v, variableCollections, variableSets))\n  const partitions = partitionVariables(normalisedVariables)\n  const styles = stylesResponse.ok ? extractStyles(stylesResponse.data) : []\n\n  const data: VariableData = {\n    file: { key: resolvedFileKey },\n    variables: partitions,\n    rawVariables: normalisedVariables,\n    styles,\n  }\n\n  const envelope = createEnvelope<ToolInput, VariableData>({ tool: TOOL_NAME, input, data, warnings, errors, rateLimit: variablesResponse.rateLimit ?? undefined, schemaVersion })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(getExitCode(errors))\n}\n\nmain().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : 'Unknown error'\n  const envelope = createEnvelope<ToolInput, EmptyData>({ tool: TOOL_NAME, input: { fileKey: null, includeStyles: false }, errors: [createError('INTERNAL', message, { stack: error instanceof Error ? error.stack : undefined })], data: {} as EmptyData })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(3)\n})\n\n"],
  "mappings": "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",
  "names": ["envelope"]
}
 diff --git a/use-figma/scripts/whoami.mjs b/use-figma/scripts/whoami.mjs new file mode 100755 index 0000000..b92613c --- /dev/null +++ b/use-figma/scripts/whoami.mjs @@ -0,0 +1,276 @@ +#!/usr/bin/env node + +// coding-tools/figma-tools/js/src/_utils/cli-args.ts +function parseArgs(argv = process.argv.slice(2)) { + const args = { _: [] }; + for (let i = 0; i < argv.length; i += 1) { + const arg = argv[i]; + if (!arg.startsWith("-") || arg === "-") { + args._.push(arg); + continue; + } + if (arg === "--") { + const remaining = argv.slice(i + 1); + args._.push(...remaining); + break; + } + const [rawKey, inlineValue] = arg.split("=", 2); + const normalisedKey = rawKey.replace(/^-+/, ""); + let value; + if (inlineValue !== void 0) { + value = inlineValue; + } else { + const next = argv[i + 1]; + if (next !== void 0 && !next.startsWith("-")) { + value = next; + i += 1; + } else { + value = true; + } + } + args[normalisedKey] = value; + } + return args; +} + +// coding-tools/figma-tools/js/src/_utils/config.ts +var config_default = { + schemaVersion: "1.0.0", + source: "agentic-coding-templates/figma-tools", + http: { + maxAttempts: 5, + initialDelayMs: 250 + } +}; + +// coding-tools/figma-tools/js/src/_utils/envelope.ts +function buildRateLimitMeta(rateLimit = {}) { + return { + remaining: rateLimit.remaining ?? null, + resetAt: rateLimit.resetAt ?? null, + attempts: rateLimit.attempts ?? 1, + lastWaitMs: rateLimit.lastWaitMs ?? 0 + }; +} +function createEnvelope({ + tool, + input = {}, + data = {}, + warnings = [], + errors = [], + rateLimit, + schemaVersion +}) { + return { + schemaVersion: schemaVersion ?? config_default.schemaVersion, + tool, + input, + meta: { + generatedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: config_default.source, + rateLimit: buildRateLimitMeta(rateLimit) + }, + data, + warnings, + errors + }; +} + +// coding-tools/figma-tools/js/src/_utils/errors.ts +var ERROR_EXIT_CODES = { + INPUT_INVALID: 1, + CONFIG_INVALID: 1, + FIGMA_AUTH: 1, + FIGMA_NOT_FOUND: 2, + FIGMA_RATE_LIMIT: 2, + NETWORK: 2, + INTERNAL: 3 +}; +function createError(code, message, detail) { + return { + code, + message, + detail: detail ?? null + }; +} +function getExitCode(errors = []) { + if (!errors.length) { + return 0; + } + return errors.reduce((max, error) => { + const exitCode = ERROR_EXIT_CODES[error.code] ?? 1; + return Math.max(max, exitCode); + }, 0); +} + +// coding-tools/figma-tools/js/src/_utils/http-client.ts +var BASE_URL = "https://api.figma.com"; +function sleep(ms) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} +function parseJsonSafely(text) { + try { + return text ? JSON.parse(text) : {}; + } catch { + return { raw: text }; + } +} +function parseRateLimit(headers, attempts, lastWaitMs) { + const remainingHeader = headers.get("x-ratelimit-remaining"); + const resetHeader = headers.get("x-ratelimit-reset"); + let remaining = null; + if (remainingHeader !== null && remainingHeader !== void 0) { + const parsed = Number(remainingHeader); + remaining = Number.isNaN(parsed) ? null : parsed; + } + let resetAt = null; + if (resetHeader) { + const numericReset = Number(resetHeader); + if (!Number.isNaN(numericReset)) { + resetAt = new Date(numericReset * 1e3).toISOString(); + } else { + const date = new Date(resetHeader); + if (!Number.isNaN(date.valueOf())) { + resetAt = date.toISOString(); + } + } + } + return { + remaining, + resetAt, + attempts, + lastWaitMs + }; +} +function computeBackoffMs(attempt, initialDelayMs) { + return initialDelayMs * 2 ** (attempt - 1); +} +async function figmaRequest(options) { + const { + path, + method = "GET", + token, + headers = {}, + body, + searchParams, + maxAttempts = config_default.http?.maxAttempts ?? 5, + initialDelayMs = config_default.http?.initialDelayMs ?? 250 + } = options; + if (!token) { + return { + ok: false, + error: createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN is missing from the environment."), + status: null, + rateLimit: null + }; + } + const url = new URL(path, BASE_URL); + if (searchParams) { + Object.entries(searchParams).forEach(([key, value]) => { + if (value === void 0 || value === null) return; + url.searchParams.append(key, String(value)); + }); + } + let attempt = 0; + let lastWaitMs = 0; + while (attempt < maxAttempts) { + attempt += 1; + const response = await fetch(url, { + method, + headers: { + "Content-Type": "application/json", + "X-Figma-Token": token, + ...headers + }, + body: body ? JSON.stringify(body) : void 0 + }); + const text = await response.text(); + const payload = parseJsonSafely(text); + const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs); + if (response.ok) { + return { ok: true, data: payload, rateLimit }; + } + const status = response.status; + if (status === 401 || status === 403) { + return { ok: false, error: createError("FIGMA_AUTH", payload?.message ?? "Figma token is unauthorized.", { status }), status, rateLimit }; + } + if (status === 404) { + return { ok: false, error: createError("FIGMA_NOT_FOUND", payload?.message ?? "Resource not found.", { status }), status, rateLimit }; + } + if (status === 429 || status >= 500) { + if (attempt >= maxAttempts) { + return { + ok: false, + error: createError(status === 429 ? "FIGMA_RATE_LIMIT" : "NETWORK", payload?.message ?? "Figma request failed after maximum retries.", { status }), + status, + rateLimit + }; + } + let waitMs = computeBackoffMs(attempt, initialDelayMs); + const resetHeader = response.headers.get("x-ratelimit-reset"); + if (resetHeader) { + const asNumber = Number(resetHeader); + if (!Number.isNaN(asNumber)) { + const resetMs = asNumber * 1e3; + const delta = resetMs - Date.now(); + if (delta > 0) waitMs = Math.max(waitMs, delta); + } + } + const jitter = Math.floor(Math.random() * 100); + lastWaitMs = waitMs + jitter; + await sleep(lastWaitMs); + continue; + } + return { ok: false, error: createError("INTERNAL", payload?.message ?? "Unexpected error from Figma API.", { status }), status, rateLimit }; + } + return { + ok: false, + error: createError("NETWORK", "Unable to reach Figma API."), + status: null, + rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs } + }; +} + +// coding-tools/figma-tools/js/src/whoami.ts +var TOOL_NAME = "whoami"; +function log(message, verbose) { + if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message} +`); +} +async function main() { + const args = parseArgs(); + const verbose = Boolean(args.verbose ?? args.v); + log("Starting...", verbose); + const warnings = []; + const errors = []; + const token = process.env.FIGMA_ACCESS_TOKEN; + if (!token || !token.trim()) { + errors.push(createError("FIGMA_AUTH", "FIGMA_ACCESS_TOKEN must be set in environment.")); + } + let envelope = createEnvelope({ tool: TOOL_NAME, warnings, errors }); + if (errors.length > 0) { + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); + } + const result = await figmaRequest({ path: "/v1/me", token }); + if (!result.ok) { + errors.push(result.error); + envelope = createEnvelope({ tool: TOOL_NAME, warnings, errors, rateLimit: result.rateLimit ?? void 0 }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(getExitCode(errors)); + } + envelope = createEnvelope({ tool: TOOL_NAME, data: result.data, warnings, errors, rateLimit: result.rateLimit }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(0); +} +main().catch((error) => { + const message = error instanceof Error ? error.message : "Unknown error"; + const envelope = createEnvelope({ tool: TOOL_NAME, input: {}, errors: [createError("INTERNAL", message)] }); + process.stdout.write(`${JSON.stringify(envelope, null, 2)} +`); + process.exit(3); +}); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/_utils/cli-args.ts", "../src/_utils/config.ts", "../src/_utils/envelope.ts", "../src/_utils/errors.ts", "../src/_utils/http-client.ts", "../src/whoami.ts"],
  "sourcesContent": ["export type CliArgValue = string | boolean;\n\nexport interface CliArgs {\n  _: string[];\n  [key: string]: CliArgValue | string[];\n}\n\nexport function parseArgs(argv: string[] = process.argv.slice(2)): CliArgs {\n  const args: CliArgs = { _: [] };\n\n  for (let i = 0; i < argv.length; i += 1) {\n    const arg = argv[i];\n\n    if (!arg.startsWith('-') || arg === '-') {\n      args._.push(arg);\n      continue;\n    }\n\n    if (arg === '--') {\n      const remaining = argv.slice(i + 1);\n      args._.push(...remaining);\n      break;\n    }\n\n    const [rawKey, inlineValue] = arg.split('=', 2);\n    const normalisedKey = rawKey.replace(/^-+/, '');\n\n    let value: CliArgValue;\n    if (inlineValue !== undefined) {\n      value = inlineValue;\n    } else {\n      const next = argv[i + 1];\n      if (next !== undefined && !next.startsWith('-')) {\n        value = next;\n        i += 1;\n      } else {\n        value = true;\n      }\n    }\n\n    args[normalisedKey] = value;\n  }\n\n  return args;\n}\n\n", "export default {\n  schemaVersion: '1.0.0',\n  source: 'agentic-coding-templates/figma-tools',\n  http: {\n    maxAttempts: 5,\n    initialDelayMs: 250,\n  },\n} as const;\n\n", "import config from './config.ts';\nimport type { ToolError } from './errors.ts';\n\nexport interface RateLimitMeta {\n  remaining: number | null;\n  resetAt: string | null;\n  attempts: number;\n  lastWaitMs: number;\n}\n\nexport interface ToolEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  schemaVersion: string;\n  tool: string;\n  input: TInput;\n  meta: {\n    generatedAt: string;\n    source: string;\n    rateLimit: RateLimitMeta;\n  };\n  data: TData;\n  warnings: string[];\n  errors: ToolError[];\n}\n\nexport interface CreateEnvelopeOptions<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n> {\n  tool: string;\n  input?: TInput;\n  data?: TData;\n  warnings?: string[];\n  errors?: ToolError[];\n  rateLimit?: Partial<RateLimitMeta>;\n  schemaVersion?: string;\n}\n\nfunction buildRateLimitMeta(rateLimit: Partial<RateLimitMeta> = {}): RateLimitMeta {\n  return {\n    remaining: rateLimit.remaining ?? null,\n    resetAt: rateLimit.resetAt ?? null,\n    attempts: rateLimit.attempts ?? 1,\n    lastWaitMs: rateLimit.lastWaitMs ?? 0,\n  };\n}\n\nexport function createEnvelope<\n  TInput extends Record<string, unknown> = Record<string, unknown>,\n  TData = unknown\n>({\n  tool,\n  input = {} as TInput,\n  data = {} as TData,\n  warnings = [],\n  errors = [],\n  rateLimit,\n  schemaVersion,\n}: CreateEnvelopeOptions<TInput, TData>): ToolEnvelope<TInput, TData> {\n  return {\n    schemaVersion: schemaVersion ?? config.schemaVersion,\n    tool,\n    input,\n    meta: {\n      generatedAt: new Date().toISOString(),\n      source: config.source,\n      rateLimit: buildRateLimitMeta(rateLimit),\n    },\n    data,\n    warnings,\n    errors,\n  };\n}\n\n", "export const ERROR_EXIT_CODES = {\n  INPUT_INVALID: 1,\n  CONFIG_INVALID: 1,\n  FIGMA_AUTH: 1,\n  FIGMA_NOT_FOUND: 2,\n  FIGMA_RATE_LIMIT: 2,\n  NETWORK: 2,\n  INTERNAL: 3,\n} as const;\n\nexport type ErrorCode = keyof typeof ERROR_EXIT_CODES;\n\nexport interface ToolError<TDetail = unknown> {\n  code: ErrorCode | string;\n  message: string;\n  detail?: TDetail | null;\n}\n\nexport function createError<TDetail = unknown>(\n  code: ErrorCode | string,\n  message: string,\n  detail?: TDetail | null\n): ToolError<TDetail> {\n  return {\n    code,\n    message,\n    detail: detail ?? null,\n  };\n}\n\nexport function getExitCode(errors: ToolError[] = []): number {\n  if (!errors.length) {\n    return 0;\n  }\n\n  return errors.reduce((max, error) => {\n    const exitCode = ERROR_EXIT_CODES[error.code as ErrorCode] ?? 1;\n    return Math.max(max, exitCode);\n  }, 0);\n}\n\n", "import config from './config.ts';\nimport { createError } from './errors.ts';\nimport type { ToolError } from './errors.ts';\nimport type { RateLimitMeta } from './envelope.ts';\n\nconst BASE_URL = 'https://api.figma.com';\n\ntype SearchParams = Record<string, string | number | boolean | null | undefined>;\n\ninterface FigmaRequestOptions {\n  path: string;\n  method?: string;\n  token?: string;\n  headers?: Record<string, string>;\n  body?: unknown;\n  searchParams?: SearchParams;\n  maxAttempts?: number;\n  initialDelayMs?: number;\n}\n\ninterface FigmaSuccess<TData> {\n  ok: true;\n  data: TData;\n  rateLimit: RateLimitMeta;\n}\n\ninterface FigmaFailure {\n  ok: false;\n  error: ToolError<{ status?: number }>;\n  status?: number | null;\n  rateLimit: RateLimitMeta | null;\n}\n\nexport type FigmaResponse<TData> = FigmaSuccess<TData> | FigmaFailure;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction parseJsonSafely(text: string): unknown {\n  try {\n    return text ? JSON.parse(text) : {};\n  } catch {\n    return { raw: text };\n  }\n}\n\nfunction parseRateLimit(headers: Headers, attempts: number, lastWaitMs: number): RateLimitMeta {\n  const remainingHeader = headers.get('x-ratelimit-remaining');\n  const resetHeader = headers.get('x-ratelimit-reset');\n\n  let remaining: number | null = null;\n  if (remainingHeader !== null && remainingHeader !== undefined) {\n    const parsed = Number(remainingHeader);\n    remaining = Number.isNaN(parsed) ? null : parsed;\n  }\n\n  let resetAt: string | null = null;\n  if (resetHeader) {\n    const numericReset = Number(resetHeader);\n    if (!Number.isNaN(numericReset)) {\n      resetAt = new Date(numericReset * 1000).toISOString();\n    } else {\n      const date = new Date(resetHeader);\n      if (!Number.isNaN(date.valueOf())) {\n        resetAt = date.toISOString();\n      }\n    }\n  }\n\n  return {\n    remaining,\n    resetAt,\n    attempts,\n    lastWaitMs,\n  };\n}\n\nfunction computeBackoffMs(attempt: number, initialDelayMs: number): number {\n  return initialDelayMs * 2 ** (attempt - 1);\n}\n\nexport async function figmaRequest<TData = unknown>(\n  options: FigmaRequestOptions\n): Promise<FigmaResponse<TData>> {\n  const {\n    path,\n    method = 'GET',\n    token,\n    headers = {},\n    body,\n    searchParams,\n    maxAttempts = config.http?.maxAttempts ?? 5,\n    initialDelayMs = config.http?.initialDelayMs ?? 250,\n  } = options;\n\n  if (!token) {\n    return {\n      ok: false,\n      error: createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN is missing from the environment.'),\n      status: null,\n      rateLimit: null,\n    };\n  }\n\n  const url = new URL(path, BASE_URL);\n\n  if (searchParams) {\n    Object.entries(searchParams).forEach(([key, value]) => {\n      if (value === undefined || value === null) return;\n      url.searchParams.append(key, String(value));\n    });\n  }\n\n  let attempt = 0;\n  let lastWaitMs = 0;\n\n  while (attempt < maxAttempts) {\n    attempt += 1;\n\n    const response = await fetch(url, {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        'X-Figma-Token': token,\n        ...headers,\n      },\n      body: body ? JSON.stringify(body) : undefined,\n    });\n\n    const text = await response.text();\n    const payload = parseJsonSafely(text) as { message?: string };\n    const rateLimit = parseRateLimit(response.headers, attempt, lastWaitMs);\n\n    if (response.ok) {\n      return { ok: true, data: payload as TData, rateLimit };\n    }\n\n    const status = response.status;\n\n    if (status === 401 || status === 403) {\n      return { ok: false, error: createError('FIGMA_AUTH', payload?.message ?? 'Figma token is unauthorized.', { status }), status, rateLimit };\n    }\n\n    if (status === 404) {\n      return { ok: false, error: createError('FIGMA_NOT_FOUND', payload?.message ?? 'Resource not found.', { status }), status, rateLimit };\n    }\n\n    if (status === 429 || status >= 500) {\n      if (attempt >= maxAttempts) {\n        return {\n          ok: false,\n          error: createError(status === 429 ? 'FIGMA_RATE_LIMIT' : 'NETWORK', payload?.message ?? 'Figma request failed after maximum retries.', { status }),\n          status,\n          rateLimit,\n        };\n      }\n\n      let waitMs = computeBackoffMs(attempt, initialDelayMs);\n      const resetHeader = response.headers.get('x-ratelimit-reset');\n      if (resetHeader) {\n        const asNumber = Number(resetHeader);\n        if (!Number.isNaN(asNumber)) {\n          const resetMs = asNumber * 1000;\n          const delta = resetMs - Date.now();\n          if (delta > 0) waitMs = Math.max(waitMs, delta);\n        }\n      }\n\n      const jitter = Math.floor(Math.random() * 100);\n      lastWaitMs = waitMs + jitter;\n      await sleep(lastWaitMs);\n      continue;\n    }\n\n    return { ok: false, error: createError('INTERNAL', payload?.message ?? 'Unexpected error from Figma API.', { status }), status, rateLimit };\n  }\n\n  return {\n    ok: false,\n    error: createError('NETWORK', 'Unable to reach Figma API.'),\n    status: null,\n    rateLimit: { remaining: null, resetAt: null, attempts: maxAttempts, lastWaitMs },\n  };\n}\n\n", "#!/usr/bin/env node\nimport { parseArgs, type CliArgs } from './_utils/cli-args.ts'\nimport { createEnvelope } from './_utils/envelope.ts'\nimport { createError, getExitCode, type ToolError } from './_utils/errors.ts'\nimport { figmaRequest } from './_utils/http-client.ts'\n\nconst TOOL_NAME = 'whoami'\n\ninterface ToolInput extends Record<string, unknown> {}\n\ninterface WhoamiResponse {\n  id?: string\n  email?: string\n  handle?: string\n}\n\nfunction log(message: string, verbose: boolean): void {\n  if (verbose) process.stderr.write(`[${TOOL_NAME}] ${message}\\n`)\n}\n\nfunction toOptionalString(value: CliArgs[string]): string | null {\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nasync function main(): Promise<void> {\n  const args = parseArgs()\n  const verbose = Boolean(args.verbose ?? args.v)\n  log('Starting...', verbose)\n\n  const warnings: string[] = []\n  const errors: ToolError[] = []\n\n  const token = process.env.FIGMA_ACCESS_TOKEN\n  if (!token || !token.trim()) {\n    errors.push(createError('FIGMA_AUTH', 'FIGMA_ACCESS_TOKEN must be set in environment.'))\n  }\n\n  let envelope = createEnvelope<ToolInput>({ tool: TOOL_NAME, warnings, errors })\n  if (errors.length > 0) {\n    process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n    process.exit(getExitCode(errors))\n  }\n\n  const result = await figmaRequest<WhoamiResponse>({ path: '/v1/me', token: token as string })\n  if (!result.ok) {\n    errors.push(result.error)\n    envelope = createEnvelope({ tool: TOOL_NAME, warnings, errors, rateLimit: result.rateLimit ?? undefined })\n    process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n    process.exit(getExitCode(errors))\n  }\n\n  envelope = createEnvelope({ tool: TOOL_NAME, data: result.data, warnings, errors, rateLimit: result.rateLimit })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(0)\n}\n\nmain().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : 'Unknown error'\n  const envelope = createEnvelope({ tool: TOOL_NAME, input: {}, errors: [createError('INTERNAL', message)] })\n  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\\n`)\n  process.exit(3)\n})\n\n"],
  "mappings": "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",
  "names": []
}
