@fugood/bricks-project 2.21.0-beta.43 → 2.21.1

package/compile/action-name-map.ts

@@ -62,6 +62,26 @@ export const templateActionNameMap = {
       height: 'TAKE_SCREENSHOT_HEIGHT',
       saveProperty: 'TAKE_SCREENSHOT_SAVE_PROPERTY',
     },
+    STORAGE_SET: {
+      storageType: 'STORAGE_TYPE',
+      storageScope: 'STORAGE_SCOPE',
+      storageKey: 'STORAGE_KEY',
+      storageValue: 'STORAGE_VALUE',
+    },
+    STORAGE_RETRIEVE: {
+      storageType: 'STORAGE_TYPE',
+      storageScope: 'STORAGE_SCOPE',
+      storageKey: 'STORAGE_KEY',
+      result: 'STORAGE_RETRIEVE_RESULT',
+      defaultValue: 'STORAGE_RETRIEVE_DEFAULT_VALUE',
+      skipIfNotFound: 'STORAGE_RETRIEVE_SKIP_IF_NOT_FOUND',
+    },
+    STORAGE_DELETE: {
+      storageType: 'STORAGE_TYPE',
+      storageScope: 'STORAGE_SCOPE',
+      storageKey: 'STORAGE_KEY',
+      all: 'STORAGE_DELETE_ALL',
+    },
     CHANNEL_SUBSCRIBE: {
       key: 'CHANNEL_SUBSCRIBE_KEY',
       type: 'CHANNEL_SUBSCRIBE_TYPE',

package/compile/index.ts

@@ -4,6 +4,7 @@ import type { ExportNamedDeclaration, FunctionDeclaration } from 'acorn'
 import escodegen from 'escodegen'
 import { generateCalulationMap } from './util'
 import { templateActionNameMap } from './action-name-map'
+import { templateEventPropsMap } from '../utils/event-props'
 import type {
   Application,
   Data,
@@ -52,6 +53,17 @@ const compileProperty = (property, errorReference: string, result = {}) => {
   return property
 }
 
+const compileEventActionValue = (templateKey, eventKey, value, errorReference) => {
+  const tmplEventProperties = templateEventPropsMap[templateKey]
+  const props = tmplEventProperties?.[eventKey]
+  if (!props) return compileProperty(value, errorReference)
+  if (props.includes(value)) return value
+  if (value?.startsWith(templateKey)) {
+    console.warn(`[Warning] Value start with template key but there is no event property: ${value} ${errorReference}`)
+  }
+  return compileProperty(value, errorReference)
+}
+
 const convertOutletKey = (templateKey: string, key: string) => {
   return `${templateKey}_${_.snakeCase(key).toUpperCase()}`
 }
@@ -128,7 +140,7 @@ const compileEvents = (
               ? compileActionParam(handlerTemplateKey, action.__actionName, input)
               : input,
             [camelCase ? 'resultFromSender' : 'result_from_sender']:
-              mapping || compileProperty(value, errorReference),
+              mapping || compileEventActionValue(handlerTemplateKey, key, value, errorReference),
           }
           if (mapping) param[camelCase ? 'resultDataMapping' : 'result_data_mapping'] = true
           parameterList.push(param)
@@ -140,7 +152,7 @@ const compileEvents = (
           const param = {
             [camelCase ? 'inputToReceiver' : 'input_to_receiver']: input().id,
             [camelCase ? 'resultFromSender' : 'result_from_sender']:
-              mapping || compileProperty(value, errorReference),
+              mapping || compileEventActionValue(handlerTemplateKey, key, value, errorReference),
           }
           if (mapping) param[camelCase ? 'resultDataMapping' : 'result_data_mapping'] = true
           parameterList.push(param)

package/index.ts

@@ -3,3 +3,4 @@ export type * from './types'
 export { makeId } from './utils/id'
 export { generateDataCalculationMapEditorInfo } from './utils/calc'
 export { linkData, useSystemData, createCanvasIdRef } from './utils/data'
+export { templateEventPropsMap } from './utils/event-props'

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.21.0-beta.43",
+  "version": "2.21.1",
   "main": "index.ts",
   "scripts": {
     "build": "node scripts/build.js"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.7.0",
     "@types/escodegen": "^0.0.10",
     "@types/lodash": "^4.17.12",
     "acorn": "^8.13.0",
     "escodegen": "^2.1.0",
     "lodash": "^4.17.4",
     "uuid": "^8.3.1"
-  },
-  "gitHead": "d66e64d1099f22f48df44cbf52295f57333b1a86"
+  }
 }

package/tools/mcp-server.ts

@@ -0,0 +1,86 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { z } from 'zod'
+import { $ } from 'bun'
+
+const server = new McpServer({
+  name: 'bricks-project',
+  version: '1.0.0',
+})
+
+const dirname = import.meta.dirname
+const projectDir = String(dirname).split('/node_modules/')[0]
+
+server.tool('compile', {}, async () => {
+  let log
+  try {
+    log = await $`bun compile`.cwd(projectDir).text()
+  } catch (err) {
+    log = err.stdout.toString() + '\n' + err.stderr.toString()
+  }
+  return {
+    content: [{ type: 'text', text: log || 'Compiled successfully' }],
+  }
+})
+
+// NOTE: Cursor (Or VSCode) seems set ELECTRON_RUN_AS_NODE to 1, so we need to unset it
+process.env.ELECTRON_RUN_AS_NODE = ''
+
+server.tool(
+  'take-preview-screenshot',
+  {
+    delay: z
+      .number()
+      .describe('Delay in milliseconds before taking screenshot')
+      .optional()
+      .default(3000),
+    width: z.number().describe('Width of the screenshot').optional().default(600),
+    height: z.number().optional().default(480),
+    responseImage: z
+      .boolean()
+      .describe(
+        'Whether to response image content (base64 encoded jpeg). If false, only saved path will be responded as text.',
+      )
+      .optional()
+      .default(false),
+  } as any,
+  async ({ delay, width, height, responseImage }: any) => {
+    let log = ''
+    let error = false
+    try {
+      const args = [
+        '--take-screenshot',
+        JSON.stringify({
+          delay,
+          width,
+          height,
+          path: `${dirname}/screenshot.jpg`,
+          closeAfter: true,
+          headless: true,
+        }),
+      ]
+      log = await $`bunx --bun electron ${dirname}/preview-main.mjs ${args}`.cwd(projectDir).text()
+    } catch (err) {
+      log = err.stdout.toString() + '\n' + err.stderr.toString()
+      error = true
+    }
+    let screenshotBase64: any = null
+    if (!error && responseImage) {
+      const screenshot = await Bun.file(`${dirname}/screenshot.jpg`).arrayBuffer()
+      screenshotBase64 = Buffer.from(screenshot).toString('base64')
+    }
+    return {
+      content: [
+        { type: 'text', text: log },
+        screenshotBase64 && {
+          type: 'image',
+          data: screenshotBase64,
+          mimeType: 'image/jpeg',
+        },
+      ].filter(Boolean),
+    }
+  },
+)
+
+const transport = new StdioServerTransport()
+await server.connect(transport)

package/tools/postinstall.ts

@@ -1,5 +1,5 @@
 import { $ } from 'bun'
-
+import { stat, readFile, writeFile } from 'fs/promises'
 const cwd = process.cwd()
 
 const libFiles = ['types', 'utils', 'index.ts']
@@ -9,4 +9,56 @@ for (const file of libFiles) {
   await $`cp -r ${__dirname}/../${file} ${cwd}/project`
 }
 
-console.log('Copied files to project/')
+console.log('Copied files to project/')
+
+async function exists(f: string) {
+  try {
+    await stat(f)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const projectMcpServer = {
+  command: 'bun',
+  args: [`${cwd}/node_modules/@fugood/bricks-project/tools/mcp-server.ts`],
+}
+
+const defaultMcpConfig = {
+  mcpServers: {
+    'bricks-project': projectMcpServer,
+  },
+}
+
+const handleMcpConfigOverride = async (mcpConfigPath: string) => {
+  let mcpConfig: { mcpServers: Record<string, typeof projectMcpServer> } | null = null
+  if (await exists(mcpConfigPath)) {
+    const configStr = await readFile(mcpConfigPath, 'utf-8')
+    try {
+      mcpConfig = JSON.parse(configStr)
+      if (!mcpConfig?.mcpServers) throw new Error('mcpServers is not defined')
+      mcpConfig.mcpServers['bricks-project'] = projectMcpServer
+    } catch (e) {
+      mcpConfig = defaultMcpConfig
+    }
+  } else {
+    mcpConfig = defaultMcpConfig
+  }
+
+  await writeFile(mcpConfigPath, `${JSON.stringify(mcpConfig, null, 2)}\n`)
+
+  console.log(`Updated ${mcpConfigPath}`)
+}
+
+if (await exists(`${cwd}/.cursorrules`)) {
+  await $`mkdir -p ${cwd}/.cursor`
+  const cursorMcpConfigPath = `${cwd}/.cursor/mcp.json`
+  await handleMcpConfigOverride(cursorMcpConfigPath)
+}
+
+if (await exists(`${cwd}/CLAUDE.md`)) {
+  await $`mkdir -p ${cwd}/.cursor`
+  const claudeCodeMcpConfigPath = `${cwd}/.mcp.json`
+  await handleMcpConfigOverride(claudeCodeMcpConfigPath)
+}

package/tools/preview-main.mjs

@@ -1,6 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { app, BrowserWindow } from 'electron'
-import { readFile } from 'fs/promises'
+import { readFile, writeFile } from 'fs/promises'
 import { watchFile } from 'fs'
 import { parseArgs } from 'util'
 
@@ -8,6 +8,7 @@ const { values } = parseArgs({
   args: process.argv,
   options: {
     'clear-cache': { type: 'boolean' },
+    'take-screenshot': { type: 'string' },
   },
   strict: true,
   allowPositionals: true,
@@ -15,6 +16,21 @@ const { values } = parseArgs({
 
 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`))
 
 const stage = process.env.BRICKS_STAGE || 'production'
@@ -29,7 +45,14 @@ const previewUrl = previewUrlMap[stage]
 if (!previewUrl) throw new Error(`Invalid BRICKS_STAGE: ${stage}`)
 
 app.on('ready', () => {
-  const mainWindow = new BrowserWindow({ width: 1280, height: 768 })
+  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)
 
@@ -38,10 +61,25 @@ app.on('ready', () => {
       type: 'config',
       configFile: { _originTitle: 'Test', ...config, title: Math.random().toString() },
       workspace: { billing: { lock: {}, plan: 'free' } },
+      showMenu: false,
     }
     mainWindow.webContents.executeJavaScript(
       `window.postMessage(JSON.stringify(${JSON.stringify(payload)}))`,
     )
+    if (takeScreenshotConfig) {
+      const { delay, width, height, path, keepOpen = false } = takeScreenshotConfig
+      setTimeout(() => {
+        console.log('Taking screenshot')
+        mainWindow.webContents.capturePage().then((image) => {
+          console.log('Writing screenshot to', path)
+          writeFile(path, image.resize({ width, height }).toJPEG(75))
+          if (!keepOpen) {
+            console.log('Closing app')
+            app.quit()
+          }
+        })
+      }, delay)
+    }
   }
 
   mainWindow.webContents.once('dom-ready', sendConfig)

package/tools/preview.ts

@@ -1,22 +1,50 @@
 import { $ } from 'bun'
 import { watch } from 'fs'
+import type { FSWatcher } from 'fs'
 import { parseArgs } from 'util'
 import { debounce } from 'lodash'
 
 const { values } = parseArgs({
   args: Bun.argv,
   options: {
-    'skip-typecheck': {
-      type: 'boolean',
-    },
-    'clear-cache': {
-      type: 'boolean',
-    },
+    'skip-typecheck': { type: 'boolean' },
+    'clear-cache': { type: 'boolean' },
+    screenshot: { type: 'boolean' },
+    'screenshot-delay': { type: 'string' },
+    'screenshot-width': { type: 'string' },
+    'screenshot-height': { type: 'string' },
+    'screenshot-path': { type: 'string' },
+    'screenshot-keep-open': { type: 'boolean' },
+    'screenshot-no-headless': { type: 'boolean' },
   },
   strict: true,
   allowPositionals: true,
 })
 
+const cwd = process.cwd()
+
+const app = await Bun.file(`${cwd}/application.json`).json()
+
+let args: string[] = []
+if (values['clear-cache']) args.push('--clear-cache')
+
+let needWatcher = true
+if (values['screenshot']) {
+  args.push(`--take-screenshot`)
+  const keepOpen = values['screenshot-keep-open'] ?? false
+  args.push(
+    JSON.stringify({
+      delay: Number(values['screenshot-delay']) || 1000,
+      width: Number(values['screenshot-width']) || 600,
+      height: Number(values['screenshot-height']) || 480,
+      path: values['screenshot-path'] || `${cwd}/screenshot.jpg`,
+      keepOpen,
+      noHeadless: values['screenshot-no-headless'] ?? false,
+    }),
+  )
+  needWatcher = keepOpen
+}
+
 const useTypecheck = !values['skip-typecheck']
 
 const compile = async () => {
@@ -26,22 +54,15 @@ const compile = async () => {
 
 await compile()
 
-const compileDebounced = debounce(compile, 500)
-
-const cwd = process.cwd()
-
-const watcher = watch(`${cwd}/subspaces`, { recursive: true }, async (event, filename) => {
-  console.log(`Detected ${event} in ${filename}`)
-  compileDebounced()
-})
-
-const app = await Bun.file(`${cwd}/application.json`).json()
-
-
-if (values['clear-cache']) {
-  await $`BRICKS_STAGE=${app.stage || 'production'} bunx --bun electron ${__dirname}/preview-main.mjs --clear-cache`
-} else {
-  await $`BRICKS_STAGE=${app.stage || 'production'} bunx --bun electron ${__dirname}/preview-main.mjs`
+let watcher: FSWatcher | null = null
+if (needWatcher) {
+  const compileDebounced = debounce(compile, 500)
+  watcher = watch(`${cwd}/subspaces`, { recursive: true }, async (event, filename) => {
+    console.log(`Detected ${event} in ${filename}`)
+    compileDebounced()
+  })
 }
 
-watcher.close()
+await $`BRICKS_STAGE=${app.stage || 'production'} bunx --bun electron ${__dirname}/preview-main.mjs ${args}`
+
+if (watcher) watcher.close()