@fugood/bricks-project 2.23.0-beta.9 → 2.23.2

package/tools/postinstall.ts

@@ -1,5 +1,6 @@
 import { $ } from 'bun'
-import { stat, readFile, writeFile } from 'fs/promises'
+import { stat, readFile, writeFile, readdir } from 'fs/promises'
+import TOML from '@iarna/toml'
 
 const cwd = process.cwd()
 
@@ -17,13 +18,10 @@ const skipCopyProject = process.argv.includes('--skip-copy-project')
 if (skipCopyProject) {
   console.log('Skipping copy of files to project/')
 } else {
-
   const libFiles = ['types', 'utils', 'index.ts']
-  
+
   await $`mkdir -p ${cwd}/project`
-  for (const file of libFiles) {
-    await $`cp -r ${__dirname}/../${file} ${cwd}/project`
-  }
+  await Promise.all(libFiles.map((file) => $`cp -r ${__dirname}/../${file} ${cwd}/project`))
   console.log('Copied files to project/')
 }
 
@@ -58,13 +56,77 @@ const handleMcpConfigOverride = async (mcpConfigPath: string) => {
   console.log(`Updated ${mcpConfigPath}`)
 }
 
-if (await exists(`${cwd}/.cursor/rules/instructions.mdc`)) {
-  const cursorMcpConfigPath = `${cwd}/.cursor/mcp.json`
-  await handleMcpConfigOverride(cursorMcpConfigPath)
+const hasClaudeCode = await exists(`${cwd}/CLAUDE.md`)
+const hasAgentsMd = await exists(`${cwd}/AGENTS.md`)
+
+if (hasClaudeCode || hasAgentsMd) {
+  const mcpConfigPath = `${cwd}/.mcp.json`
+  await handleMcpConfigOverride(mcpConfigPath)
 }
 
-if (await exists(`${cwd}/CLAUDE.md`)) {
-  await $`mkdir -p ${cwd}/.cursor`
-  const claudeCodeMcpConfigPath = `${cwd}/.mcp.json`
-  await handleMcpConfigOverride(claudeCodeMcpConfigPath)
+const setupSkills = async (skillsDir) => {
+  const packageSkillsDir = `${__dirname}/../skills`
+
+  if (await exists(packageSkillsDir)) {
+    const packageSkills = await readdir(packageSkillsDir)
+    const skillsToInstall = packageSkills.filter((skill) => !skill.startsWith('.'))
+
+    await $`mkdir -p ${skillsDir}`
+
+    await Promise.all(
+      skillsToInstall.map(async (skill) => {
+        const targetSkillDir = `${skillsDir}/${skill}`
+        if (await exists(targetSkillDir)) {
+          console.log(`Skill '${skill}' already exists, skipping`)
+        } else {
+          await $`cp -r ${packageSkillsDir}/${skill} ${targetSkillDir}`
+          console.log(`Installed skill '${skill}' to ${skillsDir}/`)
+        }
+      }),
+    )
+  }
 }
+
+if (hasClaudeCode) {
+  // Install skills that don't already exist in the project
+  await setupSkills(`${cwd}/.claude/skills`)
+}
+
+if (hasAgentsMd) {
+  // Handle codex skills
+  // Currently no signal file for codex skills, so we just check if AGENTS.md exists
+  await setupSkills(`${cwd}/.codex/skills`)
+
+  const defaultCodexMcpConfig = {
+    mcp_servers: {
+      'bricks-project': projectMcpServer,
+    },
+  }
+
+  const handleCodexMcpConfigOverride = async (mcpConfigPath: string) => {
+    let mcpConfig: { mcp_servers: Record<string, typeof projectMcpServer> } | null = null
+    if (await exists(mcpConfigPath)) {
+      const configStr = await readFile(mcpConfigPath, 'utf-8')
+      try {
+        mcpConfig = TOML.parse(configStr)
+        if (!mcpConfig?.mcp_servers) throw new Error('mcp_servers is not defined')
+        mcpConfig.mcp_servers['bricks-project'] = projectMcpServer
+      } catch (e) {
+        mcpConfig = defaultCodexMcpConfig
+      }
+    } else {
+      mcpConfig = defaultCodexMcpConfig
+    }
+
+    await writeFile(mcpConfigPath, `${TOML.stringify(mcpConfig, null, 2)}\n`)
+
+    console.log(`Updated ${mcpConfigPath}`)
+  }
+
+  // Setup MCP config (.codex/config.toml)
+  const codexConfigPath = `${cwd}/.codex/config.toml`
+  await handleCodexMcpConfigOverride(codexConfigPath)
+}
+
+// TODO: .cursor/skills if needed
+// TODO: User setting in application.json to avoid unnecessary skills/config setup

package/tools/preview-main.mjs

@@ -3,12 +3,17 @@ import { app, BrowserWindow } from 'electron'
 import { readFile, writeFile } from 'fs/promises'
 import { watchFile } from 'fs'
 import { parseArgs } from 'util'
+import * as TOON from '@toon-format/toon'
 
 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' },
   },
   strict: true,
   allowPositionals: true,
@@ -33,6 +38,24 @@ try {
 
 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 || {}
+  const matchedEntry = Object.values(automationMap)
+    .flatMap((group) => Object.entries(group.map || {}))
+    .find(([, test]) => test.title?.toLowerCase().includes(titleLike))
+  if (matchedEntry) {
+    ;[testId] = matchedEntry
+  }
+  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 = {
@@ -61,19 +84,20 @@ app.on('ready', () => {
       type: 'config',
       configFile: { _originTitle: 'Test', ...config, title: Math.random().toString() },
       workspace: { billing: { lock: {}, plan: 'free' } },
-      showMenu: false,
+      showMenu: values['show-menu'] || false,
+      testId,
     }
     mainWindow.webContents.executeJavaScript(
       `window.postMessage(JSON.stringify(${JSON.stringify(payload)}))`,
     )
     if (takeScreenshotConfig) {
-      const { delay, width, height, path, keepOpen = false } = takeScreenshotConfig
+      const { delay, width, height, path } = 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) {
+          if (noKeepOpen) {
             console.log('Closing app')
             app.quit()
           }
@@ -82,7 +106,33 @@ app.on('ready', () => {
     }
   }
 
-  mainWindow.webContents.once('dom-ready', sendConfig)
+  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) {}
+        })
+      `)
+    }
+  })
+
+  // Capture console messages from the preview
+  if (testId) {
+    mainWindow.webContents.on('console-message', (_, __, message) => {
+      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')

package/tools/preview.ts

@@ -2,7 +2,7 @@ import { $ } from 'bun'
 import { watch } from 'fs'
 import type { FSWatcher } from 'fs'
 import { parseArgs } from 'util'
-import { debounce } from 'lodash'
+import debounce from 'lodash/debounce'
 
 const { values } = parseArgs({
   args: Bun.argv,
@@ -14,8 +14,11 @@ const { values } = parseArgs({
     'screenshot-width': { type: 'string' },
     'screenshot-height': { type: 'string' },
     'screenshot-path': { type: 'string' },
-    'screenshot-keep-open': { type: 'boolean' },
     'screenshot-no-headless': { type: 'boolean' },
+    'show-menu': { type: 'boolean' },
+    'test-id': { type: 'string' },
+    'test-title-like': { type: 'string' },
+    'no-keep-open': { type: 'boolean' },
   },
   strict: true,
   allowPositionals: true,
@@ -25,24 +28,38 @@ const cwd = process.cwd()
 
 const app = await Bun.file(`${cwd}/application.json`).json()
 
-let args: string[] = []
+const 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
+  needWatcher = !values['no-keep-open']
+}
+
+if (values['show-menu']) {
+  args.push('--show-menu')
+}
+
+if (values['test-id']) {
+  args.push('--test-id', values['test-id'])
+}
+
+if (values['test-title-like']) {
+  args.push('--test-title-like', values['test-title-like'])
+}
+
+if (values['no-keep-open']) {
+  args.push('--no-keep-open')
 }
 
 const useTypecheck = !values['skip-typecheck']
@@ -63,6 +80,36 @@ if (needWatcher) {
   })
 }
 
-await $`BRICKS_STAGE=${app.stage || 'production'} bunx --bun electron ${__dirname}/preview-main.mjs ${args}`
+const proc = Bun.spawn(['bunx', '--bun', 'electron', `${__dirname}/preview-main.mjs`, ...args], {
+  env: { ...process.env, BRICKS_STAGE: app.stage || 'production' },
+  stdout: 'pipe',
+  stderr: 'inherit',
+})
+
+const reader = proc.stdout.getReader()
+const decoder = new TextDecoder()
+
+const processOutput = async () => {
+  let done = false
+  while (!done) {
+    // eslint-disable-next-line no-await-in-loop
+    const result = await reader.read()
+    ;({ done } = result)
+    if (!done) {
+      const text = decoder.decode(result.value)
+      text.split('\n').forEach((line) => {
+        if (line.startsWith('[TEST_RESULT_TOON]')) {
+          const toonData = line.replace('[TEST_RESULT_TOON]', '')
+          console.log(toonData)
+        } else if (line) {
+          console.log(line)
+        }
+      })
+    }
+  }
+}
+
+await processOutput()
+await proc.exited
 
 if (watcher) watcher.close()

package/tools/pull.ts

@@ -1,36 +1,57 @@
 import { $ } from 'bun'
 import { format } from 'prettier'
-import { pullApplicationProject, pullModuleProject } from '../api'
 
 const cwd = process.cwd()
 
+// Check git status
 const { exitCode } = await $`cd ${cwd} && git status`.nothrow()
 const isGitRepo = exitCode === 0
 
 if (isGitRepo) {
   const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
   if (unstagedChanges)
-    throw new Error('Unstaged changes found, please commit or stash your changes before deploying')
+    throw new Error('Unstaged changes found, please commit or stash your changes before pulling')
+} else {
+  const confirmContinue = prompt(
+    'No git repository found, so it will not be safe to pull, continue? (y/n)',
+  )
+  if (confirmContinue !== 'y') throw new Error('Pull cancelled')
 }
 
+// Read application.json
 const app = await Bun.file(`${cwd}/application.json`).json()
-const stage = app.stage || 'production'
-const { files, lastCommitId } =
-  app.type === 'module'
-    ? await pullModuleProject(stage, app.id)
-    : await pullApplicationProject(stage, app.id)
+
+const isModule = app.type === 'module'
+const command = isModule ? 'module' : 'app'
+
+// Fetch project files using CLI
+const result = await $`bricks ${command} project-pull ${app.id} --json`.quiet().nothrow()
+
+if (result.exitCode !== 0) {
+  const output = result.stderr.toString() || result.stdout.toString()
+  try {
+    const json = JSON.parse(output)
+    throw new Error(json.error || 'Pull failed')
+  } catch {
+    throw new Error(output || 'Pull failed')
+  }
+}
+
+const { files, lastCommitId } = JSON.parse(result.stdout.toString())
 
 let useMain = false
 if (isGitRepo) {
   const found = (await $`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
     .trim()
-    .match(/^[a-f0-9]{40}$/)
+    .match(/^[\da-f]{40}$/)
 
   const commitId = (await $`cd ${cwd} && git rev-parse HEAD`.text()).trim()
 
   if (commitId === lastCommitId) throw new Error('Commit not changed')
 
-  const branchName = 'BRICKS_PROJECT_try-pull-application'
+  const branchName = isModule
+    ? 'BRICKS_PROJECT_try-pull-module'
+    : 'BRICKS_PROJECT_try-pull-application'
 
   await $`cd ${cwd} && git branch -D ${branchName}`.nothrow()
 
@@ -40,11 +61,6 @@ if (isGitRepo) {
     await $`cd ${cwd} && git checkout -b ${branchName}`
     useMain = true
   }
-} else {
-  const confirmContinue = prompt(
-    'No git repository found, so it will not be safe to pull, continue? (y/n)',
-  )
-  if (confirmContinue !== 'y') throw new Error('Pull cancelled')
 }
 
 const prettierConfig = await Bun.file(`${cwd}/.prettierrc`)
@@ -58,7 +74,7 @@ const prettierConfig = await Bun.file(`${cwd}/.prettierrc`)
   }))
 
 await Promise.all(
-  files.map(async (file) =>
+  files.map(async (file: { name: string; input: string; formatable?: boolean }) =>
     Bun.write(
       `${cwd}/${file.name}`,
       file.formatable
@@ -70,8 +86,13 @@ await Promise.all(
 
 if (isGitRepo) {
   await $`cd ${cwd} && git add .`
-  await $`cd ${cwd} && git commit -m 'Apply ${app.name} file changes'`
+  const commitMsg = isModule
+    ? 'chore(project): apply file changes from BRICKS module'
+    : 'chore(project): apply file changes from BRICKS application'
+  await $`cd ${cwd} && git commit -m ${commitMsg}`
   if (!useMain) {
     await $`cd ${cwd} && git merge main`
   }
 }
+
+console.log(`${isModule ? 'Module' : 'App'} project pulled: ${files.length} files`)

package/types/automation.ts

@@ -0,0 +1,232 @@
+/**
+ * Automation (Test) System Types
+ *
+ * This module defines TypeScript types for the BRICKS automation/testing system.
+ * The automation system allows defining automated test sequences that can be
+ * triggered on launch, anytime, or via cron schedules.
+ */
+
+import type { Subspace } from './subspace'
+import type { Brick, Generator } from './common'
+import type { Canvas } from './canvas'
+import type { Data } from './data'
+
+// Entity reference types - can be string ID or getter function
+export type SubspaceRef = string | (() => Subspace)
+export type BrickRef = string | (() => Brick)
+export type GeneratorRef = string | (() => Generator)
+export type CanvasRef = string | (() => Canvas)
+export type DataRef = string | (() => Data)
+
+// Variable types for test variables
+export type TestVariableType = 'string' | 'number' | 'array' | 'object' | 'bool' | 'any'
+
+// Trigger types for when tests should run
+export type TestTriggerType = 'launch' | 'anytime' | 'cron'
+
+// Jump condition operators for conditional test flow
+export type JumpConditionOperator = '==' | '!=' | '>' | '>=' | '<' | '<='
+
+// Jump condition status types
+export type JumpConditionStatus = 'finished' | 'failed'
+
+// Jump condition types
+export type JumpConditionType = 'status' | 'variable'
+
+/**
+ * Jump condition for controlling test case flow
+ */
+export interface TestCaseJumpCondition {
+  type: JumpConditionType
+  // For status-based conditions
+  status?: JumpConditionStatus
+  // For variable-based conditions
+  variable?: string
+  operator?: JumpConditionOperator
+  value?: any
+  // The test case to jump to (getter function for dynamic IDs or string for static IDs)
+  jump_to: string | (() => TestCase)
+}
+
+/**
+ * Test variable definition
+ */
+export interface TestVariable {
+  __typename: 'TestVariable'
+  id: string
+  name: string
+  type: TestVariableType
+  value: any
+}
+
+/**
+ * Post delay rules for test cases
+ */
+export type PostDelayRule = 'include-action-time' | 'exclude-action-time'
+
+/**
+ * Test method names (13 methods)
+ */
+export type TestMethodName =
+  | 'brick_press'
+  | 'brick_exists'
+  | 'wait_until_brick_exists'
+  | 'wait_until_event_trigger'
+  | 'wait_until_canvas_change'
+  | 'keydown'
+  | 'keyup'
+  | 'http_request'
+  | 'assert_property'
+  | 'wait_until_property_change'
+  | 'execute_action'
+  | 'match_screenshot'
+  | 'delay'
+
+/**
+ * Run array types for each test method
+ * Each method has a specific signature: [methodName, ...args]
+ */
+
+// [methodName, subspaceId, brickId, options?]
+export type TestMethodRunBrickPress = ['brick_press', SubspaceRef, BrickRef, Record<string, any>?]
+
+// [methodName, subspaceId, brickId, frame?]
+export type TestMethodRunBrickExists = ['brick_exists', SubspaceRef, BrickRef, Record<string, any>?]
+
+// [methodName, subspaceId, brickId, timeout?, frame?]
+export type TestMethodRunWaitUntilBrickExists = [
+  'wait_until_brick_exists',
+  SubspaceRef,
+  BrickRef,
+  number?,
+  Record<string, any>?,
+]
+
+// [methodName, subspaceId, senderId, eventKey, timeout?]
+// senderId can be brick or generator
+export type TestMethodRunWaitUntilEventTrigger = [
+  'wait_until_event_trigger',
+  SubspaceRef,
+  BrickRef | GeneratorRef,
+  string,
+  number?,
+]
+
+// [methodName, subspaceId, canvasId, timeout?]
+export type TestMethodRunWaitUntilCanvasChange = [
+  'wait_until_canvas_change',
+  SubspaceRef,
+  CanvasRef,
+  number?,
+]
+
+// [methodName, keyCode, pressedKey?, flags?]
+export type TestMethodRunKeydown = ['keydown', number, string?, number?]
+
+// [methodName, keyCode, pressedKey?, flags?]
+export type TestMethodRunKeyup = ['keyup', number, string?, number?]
+
+// [methodName, url, options?]
+export type TestMethodRunHttpRequest = ['http_request', string, Record<string, any>?]
+
+// [methodName, subspaceId, propertyId, value]
+export type TestMethodRunAssertProperty = ['assert_property', SubspaceRef, DataRef, any]
+
+// [methodName, subspaceId, propertyId, value, timeout?]
+export type TestMethodRunWaitUntilPropertyChange = [
+  'wait_until_property_change',
+  SubspaceRef,
+  DataRef,
+  any,
+  number?,
+]
+
+// [methodName, subspaceId, handler, action, params?, options?]
+export type TestMethodRunExecuteAction = [
+  'execute_action',
+  SubspaceRef,
+  string,
+  string,
+  Record<string, any>?,
+  Record<string, any>?,
+]
+
+// [methodName, screenshotName, threshold?, maxRetry?]
+export type TestMethodRunMatchScreenshot = ['match_screenshot', string, number?, number?]
+
+// [methodName, subspaceId?, propertyId?, defaultValue?]
+export type TestMethodRunDelay = ['delay', SubspaceRef?, DataRef?, number?]
+
+/**
+ * Union type for all test method run arrays
+ */
+export type TestMethodRun =
+  | TestMethodRunBrickPress
+  | TestMethodRunBrickExists
+  | TestMethodRunWaitUntilBrickExists
+  | TestMethodRunWaitUntilEventTrigger
+  | TestMethodRunWaitUntilCanvasChange
+  | TestMethodRunKeydown
+  | TestMethodRunKeyup
+  | TestMethodRunHttpRequest
+  | TestMethodRunAssertProperty
+  | TestMethodRunWaitUntilPropertyChange
+  | TestMethodRunExecuteAction
+  | TestMethodRunMatchScreenshot
+  | TestMethodRunDelay
+
+/**
+ * Test case definition
+ */
+export interface TestCase {
+  __typename: 'TestCase'
+  id: string
+  name: string
+  run: TestMethodRun
+  exit_on_failed: boolean
+  commented: boolean
+  pre_delay: number
+  post_delay: number
+  post_delay_rule?: PostDelayRule
+  jump_cond: TestCaseJumpCondition[]
+}
+
+/**
+ * Local sync mode for tests
+ */
+export type LocalSyncMode = 'main-only' | 'minor-only'
+
+/**
+ * Automation test definition
+ */
+export interface AutomationTest {
+  __typename: 'AutomationTest'
+  id: string
+  title: string
+  timeout: number
+  trigger_type?: TestTriggerType
+  cron?: string // Cron expression when trigger_type is 'cron'
+  skip_trigger_type_check?: boolean
+  local_sync?: LocalSyncMode
+  cases: TestCase[]
+  variables: TestVariable[]
+  meta?: Record<string, any>
+}
+
+/**
+ * Automation test map (a collection of tests)
+ */
+export interface AutomationTestMap {
+  __typename: 'AutomationTestMap'
+  id: string
+  title: string
+  createdAt: number
+  tests: AutomationTest[]
+}
+
+/**
+ * Root automation map type (record of automation test maps by ID)
+ */
+export type AutomationMap = {
+  [mapId: string]: AutomationTestMap
+}

package/types/brick-base.ts

@@ -1,3 +1,4 @@
+/* Auto generated by build script */
 import type { SwitchCondInnerStateCurrentCanvas, SwitchCondData, SwitchDef } from './switch'
 import type { Data, DataLink } from './data'
 import type { Animation, AnimationBasicEvents } from './animation'