@fugood/bricks-ctor 2.25.0-beta.8 → 2.25.0-beta.81

package/tools/mcp-tools/icons.ts

@@ -1,81 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
-import * as TOON from '@toon-format/toon'
-import Fuse from 'fuse.js'
-import glyphmap from '../icons/fa6pro-glyphmap.json'
-import glyphmapMeta from '../icons/fa6pro-meta.json'
-
-type IconStyle = 'brands' | 'duotone' | 'light' | 'regular' | 'solid' | 'thin'
-
-// Bitmask bits for icon family membership (compact metadata format)
-const STYLE_BITS: Record<IconStyle, number> = {
-  brands: 1,
-  thin: 2,
-  light: 4,
-  regular: 8,
-  solid: 16,
-  duotone: 256,
-}
-const ALL_STYLES = Object.keys(STYLE_BITS) as IconStyle[]
-
-// Metadata is shipped as { bitmaskValue: [iconName, ...] } with the dominant
-// 510 (all non-brand families) omitted. Expand to a flat lookup once.
-const DEFAULT_BITMASK = 510
-const compactMeta = glyphmapMeta as Record<string, string[]>
-const iconMeta: Record<string, number> = {}
-for (const name of Object.keys(glyphmap)) iconMeta[name] = DEFAULT_BITMASK
-for (const bitmaskKey of Object.keys(compactMeta)) {
-  const value = Number(bitmaskKey)
-  const names = compactMeta[bitmaskKey]
-  for (const name of names) iconMeta[name] = value
-}
-
-const iconList = Object.entries(glyphmap as Record<string, number>).map(([name, code]) => {
-  const bits = iconMeta[name] || 0
-  const styles = ALL_STYLES.filter((s) => bits & STYLE_BITS[s])
-  return { name, code, styles }
-})
-
-const iconFuse = new Fuse(iconList, {
-  keys: ['name'],
-  threshold: 0.3,
-  includeScore: true,
-})
-
-export function register(server: McpServer) {
-  server.tool(
-    'icon_search',
-    {
-      query: z.string().describe('Search keywords for FontAwesome 6 Pro icons'),
-      limit: z.number().min(1).max(100).optional().default(10),
-      style: z
-        .enum(['brands', 'duotone', 'light', 'regular', 'solid', 'thin'])
-        .optional()
-        .describe('Filter by icon style'),
-    },
-    async ({ query, limit, style }) => {
-      let results = iconFuse.search(query, { limit: style ? limit * 3 : limit })
-
-      if (style) {
-        results = results.filter((r) => r.item.styles.includes(style)).slice(0, limit)
-      }
-
-      const icons = results.map((r) => ({
-        name: r.item.name,
-        code: r.item.code,
-        unicode: `U+${r.item.code.toString(16).toUpperCase()}`,
-        styles: r.item.styles,
-        score: r.score,
-      }))
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: TOON.encode({ count: icons.length, icons }),
-          },
-        ],
-      }
-    },
-  )
-}

package/tools/mcp-tools/lottie.ts

@@ -1,102 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
-import * as TOON from '@toon-format/toon'
-
-const LOTTIEFILES_API_URL = 'https://lottiefiles.com/api'
-
-export function register(server: McpServer) {
-  server.tool(
-    'lottie_search',
-    {
-      query: z.string().describe('Search keywords for animations'),
-      page: z.number().min(1).optional().default(1),
-      limit: z.number().min(1).max(100).optional().default(10),
-    },
-    async ({ query, page, limit }) => {
-      try {
-        const url = new URL(`${LOTTIEFILES_API_URL}/search/get-animations`)
-        url.searchParams.set('query', query)
-        url.searchParams.set('page', String(page))
-        url.searchParams.set('limit', String(limit))
-        url.searchParams.set('format', 'json')
-
-        const response = await fetch(url.toString())
-        const data = await response.json()
-        const animations = data?.data?.data ?? []
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: TOON.encode({ count: animations.length, animations }),
-            },
-          ],
-        }
-      } catch (err: any) {
-        return {
-          content: [{ type: 'text', text: `Failed to search animations: ${err.message}` }],
-        }
-      }
-    },
-  )
-
-  server.tool(
-    'lottie_get_details',
-    {
-      id: z.string().describe('Animation file ID'),
-    },
-    async ({ id }) => {
-      try {
-        const url = new URL(`${LOTTIEFILES_API_URL}/animations/get-animation-data`)
-        url.searchParams.set('fileId', id)
-        url.searchParams.set('format', 'json')
-
-        const response = await fetch(url.toString())
-        const data = await response.json()
-
-        return {
-          content: [{ type: 'text', text: TOON.encode(data) }],
-        }
-      } catch (err: any) {
-        return {
-          content: [{ type: 'text', text: `Failed to get animation: ${err.message}` }],
-        }
-      }
-    },
-  )
-
-  server.tool(
-    'lottie_popular',
-    {
-      page: z.number().min(1).optional().default(1),
-      limit: z.number().min(1).max(100).optional().default(10),
-    },
-    async ({ page, limit }) => {
-      try {
-        const url = new URL(
-          `${LOTTIEFILES_API_URL}/iconscout/popular-animations-weekly?api=%26sort%3Dpopular`,
-        )
-        url.searchParams.set('page', String(page))
-        url.searchParams.set('limit', String(limit))
-        url.searchParams.set('format', 'json')
-
-        const response = await fetch(url.toString())
-        const data = await response.json()
-        const animations = data?.popularWeeklyData?.data ?? []
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: TOON.encode({ count: animations.length, animations }),
-            },
-          ],
-        }
-      } catch (err: any) {
-        return {
-          content: [{ type: 'text', text: `Failed to get popular animations: ${err.message}` }],
-        }
-      }
-    },
-  )
-}

package/tools/mcp-tools/media.ts

@@ -1,110 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
-import { sh } from '../_shell'
-
-const runBricks = async (projectDir: string, ...args: string[]) => {
-  try {
-    return await sh`bunx bricks ${args}`.cwd(projectDir).text()
-  } catch (err: any) {
-    throw new Error(err.stderr?.toString() || err.message)
-  }
-}
-
-export function register(server: McpServer, projectDir: string) {
-  server.tool('media_boxes', {}, async () => {
-    try {
-      const output = await runBricks(projectDir, 'media', 'boxes')
-      return { content: [{ type: 'text', text: output }] }
-    } catch (err: any) {
-      return { content: [{ type: 'text', text: `Failed to list media boxes: ${err.message}` }] }
-    }
-  })
-
-  server.tool('media_get_box', { id: z.string().describe('Media box ID') }, async ({ id }) => {
-    try {
-      const output = await runBricks(projectDir, 'media', 'box', id)
-      return { content: [{ type: 'text', text: output }] }
-    } catch (err: any) {
-      return { content: [{ type: 'text', text: `Failed to get media box: ${err.message}` }] }
-    }
-  })
-
-  server.tool(
-    'media_files',
-    {
-      boxId: z.string().describe('Media box ID'),
-      types: z.string().describe('Comma-separated file types to include').optional(),
-      userTag: z.array(z.string()).describe('Filter by user tags').optional(),
-      limit: z.number().describe('Limit results').optional(),
-      offset: z.number().describe('Offset results').optional(),
-    },
-    async ({ boxId, types, userTag, limit, offset }) => {
-      try {
-        const args = ['media', 'files', boxId]
-        if (types) args.push('-t', types)
-        if (userTag) userTag.forEach((tag) => args.push('-u', tag))
-        if (limit != null) args.push('-l', String(limit))
-        if (offset != null) args.push('-o', String(offset))
-        const output = await runBricks(projectDir, ...args)
-        return { content: [{ type: 'text', text: output }] }
-      } catch (err: any) {
-        return { content: [{ type: 'text', text: `Failed to list media files: ${err.message}` }] }
-      }
-    },
-  )
-
-  server.tool('media_file', { id: z.string().describe('Media file ID') }, async ({ id }) => {
-    try {
-      const output = await runBricks(projectDir, 'media', 'file', id)
-      return { content: [{ type: 'text', text: output }] }
-    } catch (err: any) {
-      return { content: [{ type: 'text', text: `Failed to get media file: ${err.message}` }] }
-    }
-  })
-
-  server.tool(
-    'media_upload_files',
-    {
-      boxId: z.string().describe('Target media box ID'),
-      files: z.array(z.string()).min(1).describe('File paths to upload'),
-      description: z.string().describe('File description').optional(),
-      userTags: z.array(z.string()).max(15).describe('User tags (max 15)').optional(),
-      imageVersion: z
-        .array(z.string())
-        .describe('Image resize specs as WxH or WxH:STRATEGY')
-        .optional(),
-      imageVersionType: z.enum(['jpg', 'png']).describe('Image output format').optional(),
-      enableAiAnalysis: z.boolean().describe('Enable AI analysis').optional(),
-      aiInstruction: z.string().describe('Custom AI analysis instruction').optional(),
-      concurrency: z.number().min(1).describe('Max concurrent uploads').optional(),
-    },
-    async ({
-      boxId,
-      files,
-      description,
-      userTags,
-      imageVersion,
-      imageVersionType,
-      enableAiAnalysis,
-      aiInstruction,
-      concurrency,
-    }) => {
-      try {
-        const args = ['media', 'upload', boxId, ...files]
-        if (description) args.push('-d', description)
-        if (userTags) userTags.forEach((tag) => args.push('-t', tag))
-        if (imageVersion) imageVersion.forEach((spec) => args.push('--image-version', spec))
-        if (imageVersionType) args.push('--image-version-type', imageVersionType)
-        if (enableAiAnalysis) args.push('--enable-ai-analysis')
-        if (aiInstruction) args.push('--ai-instruction', aiInstruction)
-        if (concurrency != null) args.push('--concurrency', String(concurrency))
-        const output = await runBricks(projectDir, ...args)
-        return { content: [{ type: 'text', text: output }] }
-      } catch (err: any) {
-        return {
-          content: [{ type: 'text', text: `Failed to upload media files: ${err.message}` }],
-        }
-      }
-    },
-  )
-}

package/tools/preview-main.mjs

@@ -1,306 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import { app, BrowserWindow } from 'electron'
-import { readFile, writeFile } from 'fs/promises'
-import { watchFile } from 'fs'
-import { createServer } from 'http'
-import { parseArgs } from 'util'
-import * as TOON from '@toon-format/toon'
-
-for (const stream of [process.stdout, process.stderr]) {
-  stream.on('error', (err) => {
-    if (err.code !== 'EPIPE') throw err
-  })
-}
-
-const { values } = parseArgs({
-  args: process.argv,
-  options: {
-    'clear-cache': { type: 'boolean' },
-    'take-screenshot': { type: 'string' },
-    'show-menu': { type: 'boolean' },
-    'test-id': { type: 'string' },
-    'test-title-like': { type: 'string' },
-    'no-keep-open': { type: 'boolean' },
-    'cdp-port': { type: 'string' },
-  },
-  strict: true,
-  allowPositionals: true,
-})
-
-const cwd = process.cwd()
-
-let takeScreenshotConfig = null
-try {
-  if (values['take-screenshot']) {
-    takeScreenshotConfig = JSON.parse(values['take-screenshot'])
-    if (!takeScreenshotConfig.path) takeScreenshotConfig.path = `${cwd}/screenshot.jpg`
-    if (!takeScreenshotConfig.width) takeScreenshotConfig.width = 1280
-    if (!takeScreenshotConfig.height) takeScreenshotConfig.height = 768
-    if (!takeScreenshotConfig.delay) takeScreenshotConfig.delay = 1000
-  }
-} catch (e) {
-  console.error('Invalid take-screenshot config', e)
-  // eslint-disable-next-line unicorn/no-process-exit
-  process.exit(1)
-}
-
-let config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
-
-// Resolve testId from testTitleLike
-let testId = values['test-id'] || null
-if (!testId && values['test-title-like']) {
-  const titleLike = values['test-title-like'].toLowerCase()
-  const automationMap = config.automation_map || {}
-  for (const group of Object.values(automationMap)) {
-    const found = Object.entries(group.map || {}).find(([, test]) =>
-      test.title?.toLowerCase().includes(titleLike),
-    )
-    if (found) {
-      ;[testId] = found
-      break
-    }
-  }
-  if (!testId) {
-    throw new Error(`No automation found matching title: ${values['test-title-like']}`)
-  }
-}
-
-const noKeepOpen = values['no-keep-open'] ?? false
-
-const stage = process.env.BRICKS_STAGE || 'production'
-
-const previewUrlMap = {
-  production: 'https://control.bricks.tools/applicationPreview.html',
-  beta: 'https://control-beta.bricks.tools/applicationPreview.html',
-  development: 'http://localhost:3006/dev-applicationPreview.html',
-}
-
-const previewUrl = previewUrlMap[stage]
-if (!previewUrl) throw new Error(`Invalid BRICKS_STAGE: ${stage}`)
-
-// --- CDP WebSocket Server ---
-// Bridges external CDP clients to the preview's postMessage-based CDP bridge.
-// Usage: --cdp-port 9222
-
-const startCdpServer = async (mainWindow, port) => {
-  const { WebSocketServer } = await import('ws')
-  const clients = new Set()
-
-  // Inject a listener in the preview that forwards CDP responses/events via console
-  const injectCdpRelay = () =>
-    mainWindow.webContents.executeJavaScript(`
-      if (!window.__cdpRelayInstalled) {
-        window.__cdpRelayInstalled = true
-        window.addEventListener('message', (evt) => {
-          try {
-            const d = typeof evt.data === 'string' ? JSON.parse(evt.data) : evt.data
-            if (d && (d.type === 'cdp-response' || d.type === 'cdp-event'))
-              console.log('[CDP]' + JSON.stringify(d))
-          } catch {}
-        })
-      }
-    `)
-
-  // Capture CDP messages from the preview's console output
-  mainWindow.webContents.on('console-message', (_event, ...rest) => {
-    const message = typeof rest[0] === 'object' ? rest[0].message : rest[1]
-    if (!message?.startsWith('[CDP]')) return
-    try {
-      const data = JSON.parse(message.slice(5))
-      // Translate to standard CDP wire format (strip internal type field)
-      const wireMsg =
-        data.type === 'cdp-response'
-          ? { id: data.id, result: data.result, error: data.error }
-          : { method: data.method, params: data.params }
-      if (data.sessionId) wireMsg.sessionId = data.sessionId
-      const payload = JSON.stringify(wireMsg)
-      for (const c of clients) if (c.readyState === 1) c.send(payload)
-    } catch {}
-  })
-
-  // Find an available port before binding
-  const findPort = (p) =>
-    new Promise((resolve) => {
-      const probe = createServer()
-      probe.once('error', () => {
-        if (p < port + 100) resolve(findPort(p + 1))
-        else resolve(null)
-      })
-      probe.listen(p, () => probe.close(() => resolve(p)))
-    })
-
-  const actualPort = await findPort(port)
-  if (!actualPort) {
-    console.warn(`CDP server: no available port in range ${port}-${port + 99}`)
-    return
-  }
-
-  // HTTP discovery endpoints (chrome://inspect, Playwright, etc.)
-  const httpServer = createServer((req, res) => {
-    if (req.url === '/json/list' || req.url === '/json') {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify([
-          {
-            description: 'BRICKS Preview (CTOR Preview)',
-            id: 'bricks-preview',
-            title: 'BRICKS Preview',
-            type: 'page',
-            url: previewUrl,
-            webSocketDebuggerUrl: `ws://localhost:${actualPort}/ws`,
-          },
-        ]),
-      )
-      return
-    }
-    if (req.url === '/json/version') {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(JSON.stringify({ Browser: 'BRICKS Preview', 'Protocol-Version': '1.3' }))
-      return
-    }
-    // bricks-cli discovery endpoint
-    if (req.url === '/devtools/info') {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          name: 'BRICKS Preview',
-          port: actualPort,
-          protocols: ['cdp'],
-          hasPasscode: false,
-        }),
-      )
-      return
-    }
-    res.writeHead(404)
-    res.end()
-  })
-
-  const wss = new WebSocketServer({ server: httpServer, path: '/ws' })
-  wss.on('connection', (ws) => {
-    clients.add(ws)
-    injectCdpRelay()
-
-    ws.on('message', (raw) => {
-      try {
-        const req = JSON.parse(raw.toString())
-        const cdpReq = JSON.stringify({
-          type: 'cdp-request',
-          id: req.id,
-          method: req.method,
-          params: req.params || {},
-          sessionId: req.sessionId,
-        })
-        mainWindow.webContents.executeJavaScript(`window.postMessage(${JSON.stringify(cdpReq)})`)
-      } catch {}
-    })
-
-    ws.on('close', () => clients.delete(ws))
-  })
-
-  httpServer.listen(actualPort, () => {
-    console.log(`CDP server: ws://localhost:${actualPort}/ws`)
-    console.log(
-      `Inspect:   devtools://devtools/bundled/inspector.html?ws=localhost:${actualPort}/ws`,
-    )
-  })
-}
-
-app.on('ready', () => {
-  let show = true
-  if (takeScreenshotConfig && !takeScreenshotConfig.noHeadless) show = false
-  const mainWindow = new BrowserWindow({
-    width: takeScreenshotConfig?.width || 1280,
-    height: takeScreenshotConfig?.height || 768,
-    frame: !takeScreenshotConfig,
-    show,
-  })
-  mainWindow.setBackgroundColor('#333')
-  mainWindow.loadURL(previewUrl)
-
-  const sendConfig = () => {
-    const payload = {
-      type: 'config',
-      configFile: { _originTitle: 'Test', ...config, title: Math.random().toString() },
-      workspace: { billing: { lock: {}, plan: 'free' } },
-      showMenu: values['show-menu'] || false,
-      testId,
-    }
-    mainWindow.webContents.executeJavaScript(
-      `window.postMessage(JSON.stringify(${JSON.stringify(payload)}))`,
-    )
-    if (takeScreenshotConfig) {
-      const { delay, width, height, path } = takeScreenshotConfig
-      setTimeout(async () => {
-        let screenshotFailed = false
-        console.log('Taking screenshot')
-        try {
-          const image = await mainWindow.webContents.capturePage()
-          console.log('Writing screenshot to', path)
-          await writeFile(path, image.resize({ width, height }).toJPEG(75))
-        } catch (err) {
-          screenshotFailed = true
-          console.error('Screenshot capture/write failed', err)
-        } finally {
-          if (noKeepOpen) {
-            console.log('Closing app')
-            if (screenshotFailed) app.exit(1)
-            else app.quit()
-          }
-        }
-      }, delay)
-    }
-  }
-
-  mainWindow.webContents.once('dom-ready', () => {
-    sendConfig()
-    // Listen for test result messages from the preview
-    if (testId) {
-      mainWindow.webContents.executeJavaScript(`
-        window.addEventListener('message', (evt) => {
-          try {
-            const data = JSON.parse(evt.data)
-            if (data.type === 'bricks-preview-test-result') {
-              console.log('[TEST_RESULT]' + JSON.stringify(data))
-            }
-          } catch (e) {}
-        })
-      `)
-    }
-    // Start CDP WebSocket server if requested
-    const cdpPort = values['cdp-port'] ? parseInt(values['cdp-port'], 10) : null
-    if (cdpPort) startCdpServer(mainWindow, cdpPort)
-  })
-
-  // Capture console messages from the preview
-  if (testId) {
-    mainWindow.webContents.on('console-message', (_event, ...rest) => {
-      const message = typeof rest[0] === 'object' ? rest[0].message : rest[1]
-      if (message?.startsWith('[TEST_RESULT]')) {
-        const data = JSON.parse(message.replace('[TEST_RESULT]', ''))
-        console.log(`[TEST_RESULT_TOON]${TOON.encode(data.result)}`)
-        if (!takeScreenshotConfig && noKeepOpen) app.quit()
-      }
-    })
-  }
-
-  if (values['clear-cache']) {
-    console.log('Clearing cache')
-    mainWindow.webContents.session.clearCache()
-  }
-
-  mainWindow.on('close', () => app.quit())
-
-  watchFile(
-    `${cwd}/.bricks/build/application-config.json`,
-    {
-      bigint: false,
-      persistent: true,
-      interval: 1000,
-    },
-    async () => {
-      console.log('Detected config changed')
-      config = JSON.parse(await readFile(`${cwd}/.bricks/build/application-config.json`))
-      sendConfig()
-    },
-  )
-})