@fugood/bricks-ctor 2.25.0-beta.50 → 2.25.0-beta.52

package/compile/__tests__/index.test.js

@@ -14,7 +14,7 @@ import os from 'node:os'
 import path from 'node:path'
 
 import { sh } from '../../tools/_shell'
-import { checkConfig, compile } from '../index'
+import { checkConfig, compile, compileTestCase } from '../index'
 
 const SUBSPACE_ID = 'SUBSPACE_00000000-0000-0000-0000-000000000001'
 const CANVAS_ID = 'CANVAS_00000000-0000-0000-0000-000000000001'
@@ -362,4 +362,25 @@ describe('compile linked-module subspace', () => {
     expect(first.subspace_map[LINKED_SUBSPACE_ID].root_canvas_id).toBe(firstKeys[0])
     expect(second.subspace_map[LINKED_SUBSPACE_ID].root_canvas_id).toBe(firstKeys[0])
   })
+
+  test('compileTestCase resolves a jump_to getter to its id (survives serialization)', () => {
+    // Regression: jump_cond[].jump_to may be a getter (() => TestCase) for dynamic case ids — the
+    // project generator emits `jump_to: () => caseVar`. compileTestCase passed it through verbatim
+    // (unlike the `run` array, which resolves getters via compileRunElement), so JSON.stringify of
+    // the compiled config dropped the function and the conditional jump silently vanished.
+    const compiled = compileTestCase({
+      __typename: 'TestCase',
+      id: 'TEST_CASE_src',
+      name: 'src',
+      run: [],
+      jump_cond: [
+        { type: 'status', status: 'finished', jump_to: () => ({ id: 'TEST_CASE_target' }) },
+        { type: 'status', status: 'failed', jump_to: 'TEST_CASE_literal' },
+      ],
+    })
+    // The compiled config is serialized to disk, so the value must survive JSON round-tripping.
+    const serialized = JSON.parse(JSON.stringify(compiled))
+    expect(serialized.jump_cond[0].jump_to).toBe('TEST_CASE_target') // getter resolved to its id
+    expect(serialized.jump_cond[1].jump_to).toBe('TEST_CASE_literal') // string passes through
+  })
 })

package/compile/__tests__/util.test.js

@@ -65,6 +65,26 @@ describe('validateConfig', () => {
     expect(() => validateConfig(baseConfig())).not.toThrow()
   })
 
+  // Regression: the overlap checks tested `config.inputs[id]` (the OBJECT_SET path) for
+  // truthiness instead of asking whether `id` is an input key. An empty path ('' is
+  // OBJECT_SET's default "set whole object") is a legitimate input value, so an input with
+  // an empty path that also targets output/error/outputs slipped the guard and compiled into
+  // a node double-wired as both input and output.
+  test('throws when output collides with an input whose path is empty', () => {
+    const config = baseConfig({ inputs: { a: '' }, output: 'a' })
+    expect(() => validateConfig(config)).toThrow(/key: output/)
+  })
+
+  test('throws when error collides with an input whose path is empty', () => {
+    const config = baseConfig({ inputs: { a: '' }, error: 'a' })
+    expect(() => validateConfig(config)).toThrow(/key: error/)
+  })
+
+  test('throws when an outputs entry references an input whose path is empty', () => {
+    const config = baseConfig({ inputs: { a: '' }, outputs: { x: ['a'] } })
+    expect(() => validateConfig(config)).toThrow(/key: outputs/)
+  })
+
   test('throws when error and output target the same id', () => {
     const config = baseConfig({ output: 'shared', error: 'shared' })
     expect(() => validateConfig(config)).toThrow(/key: error\/output/)

package/compile/index.ts

@@ -584,7 +584,7 @@ function compileRunArray(run: unknown[]): unknown[] {
 /**
  * Compile typed TestCase to raw format (strips __typename)
  */
-const compileTestCase = (testCase: TestCase) => ({
+export const compileTestCase = (testCase: TestCase) => ({
   id: testCase.id,
   name: testCase.name,
   hide_short_ref: testCase.hideShortRef,
@@ -606,7 +606,10 @@ const compileTestCase = (testCase: TestCase) => ({
       variable: cond.variable,
       operator: cond.operator,
       value: cond.value,
-      jump_to: cond.jump_to,
+      // `jump_to` may be a getter (() => TestCase) for dynamic case ids (the project generator
+      // emits this form). Resolve it to its id like the `run` array does — otherwise the function
+      // is JSON-serialized to nothing and the conditional jump silently vanishes from the config.
+      jump_to: compileRunElement(cond.jump_to),
     }
   }),
 })

package/compile/util.ts

@@ -18,13 +18,18 @@ const errorMsg = 'Not allow duplicate set property id between inputs / outputs /
 export const validateConfig = (config: ScriptConfig) => {
   // Skip input/output overlap validation in manual mode (allows same data node in both)
   if (config.trigger_mode === 'manual') return
-  if (config.error && config.inputs[config.error]) {
+  // `inputs` is keyed by data-node id with the OBJECT_SET path as the *value*. The overlap
+  // check is "is this id also an input?" — a key-existence question — so test key presence,
+  // not the path's truthiness. An empty path ('' = OBJECT_SET's default "set whole object")
+  // is a legitimate input value that would otherwise slip the overlap guard.
+  const isInput = (id: string) => Object.prototype.hasOwnProperty.call(config.inputs, id)
+  if (config.error && isInput(config.error)) {
     throw new Error(`${errorMsg}. key: error`)
   }
-  if (config.output && config.inputs[config.output]) {
+  if (config.output && isInput(config.output)) {
     throw new Error(`${errorMsg}. key: output`)
   }
-  if (Object.values(config.outputs).some((value) => value.some((id) => config.inputs[id]))) {
+  if (Object.values(config.outputs).some((value) => value.some(isInput))) {
     throw new Error(`${errorMsg}. key: outputs`)
   }
   // The same data-node id reused across the output-side targets (output / error / outputs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.50",
+  "version": "2.25.0-beta.52",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -11,7 +11,7 @@
     "@babel/parser": "7.28.5",
     "@babel/traverse": "7.28.5",
     "@babel/types": "7.28.5",
-    "@fugood/bricks-cli": "^2.25.0-beta.50",
+    "@fugood/bricks-cli": "^2.25.0-beta.52",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
@@ -29,5 +29,5 @@
   "peerDependencies": {
     "oxfmt": "^0.36.0"
   },
-  "gitHead": "3614445cd0166e40634f69c6238299bb63f4f597"
+  "gitHead": "f6869285ea21123990934411ea190d9fbf12ea7f"
 }

package/tools/__tests__/_mcp-config.test.ts

@@ -0,0 +1,67 @@
+import { mkdtemp, readFile, writeFile, rm } from 'fs/promises'
+import { tmpdir } from 'os'
+import * as path from 'path'
+import { handleMcpConfigOverride } from '../_mcp-config'
+
+// bricks-project's tsconfig has no @types/jest, so declare the globals this test uses
+// (mirrors tools/__tests__/_cli-error.test.ts).
+declare const describe: (name: string, fn: () => void) => void
+declare const it: (name: string, fn: () => void | Promise<void>) => void
+declare const expect: (actual: unknown) => {
+  toBe: (expected: unknown) => void
+  toEqual: (expected: unknown) => void
+}
+
+const projectMcpServer = { command: 'bun', args: ['mcp-server.ts'] }
+
+const withTempMcp = async (contents: string | null, fn: (p: string) => Promise<void>) => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'bf-mcp-'))
+  const mcpPath = path.join(dir, '.mcp.json')
+  if (contents !== null) await writeFile(mcpPath, contents)
+  try {
+    await fn(mcpPath)
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+}
+
+describe('handleMcpConfigOverride', () => {
+  it('injects bricks-ctor while preserving the user other servers', async () => {
+    await withTempMcp(
+      JSON.stringify({ mcpServers: { smartbear: { command: 'npx' } } }),
+      async (p) => {
+        await handleMcpConfigOverride(p, projectMcpServer)
+        const result = JSON.parse(await readFile(p, 'utf-8'))
+        expect(result.mcpServers.smartbear).toEqual({ command: 'npx' })
+        expect(result.mcpServers['bricks-ctor']).toEqual(projectMcpServer)
+      },
+    )
+  })
+
+  it('does not clobber a malformed .mcp.json (regression: user servers were wiped)', async () => {
+    // trailing comma -> JSON.parse throws; the whole file used to be overwritten with the
+    // default, silently deleting every other configured server.
+    const malformed = '{ "mcpServers": { "smartbear": { "command": "npx" }, } }'
+    await withTempMcp(malformed, async (p) => {
+      await handleMcpConfigOverride(p, projectMcpServer)
+      expect(await readFile(p, 'utf-8')).toBe(malformed)
+    })
+  })
+
+  it('backfills mcpServers when missing without dropping other top-level keys', async () => {
+    await withTempMcp(JSON.stringify({ otherKey: 'keep-me' }), async (p) => {
+      await handleMcpConfigOverride(p, projectMcpServer)
+      const result = JSON.parse(await readFile(p, 'utf-8'))
+      expect(result.otherKey).toBe('keep-me')
+      expect(result.mcpServers['bricks-ctor']).toEqual(projectMcpServer)
+    })
+  })
+
+  it('writes a default config when no .mcp.json exists', async () => {
+    await withTempMcp(null, async (p) => {
+      await handleMcpConfigOverride(p, projectMcpServer)
+      const result = JSON.parse(await readFile(p, 'utf-8'))
+      expect(result.mcpServers['bricks-ctor']).toEqual(projectMcpServer)
+    })
+  })
+})

package/tools/_mcp-config.ts

@@ -0,0 +1,42 @@
+import { readFile, writeFile, stat } from 'fs/promises'
+
+const exists = async (f: string) => {
+  try {
+    await stat(f)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// Refresh the `bricks-ctor` entry in a project's `.mcp.json` while preserving every other MCP
+// server the user configured. A malformed `.mcp.json` is left untouched (with a warning)
+// rather than overwritten with the default — clobbering it would silently delete the user's
+// other server entries. This mirrors `setupClaudeAutoMode`'s handling of a malformed
+// `settings.local.json` in postinstall.ts.
+export const handleMcpConfigOverride = async (mcpConfigPath: string, projectMcpServer: object) => {
+  let mcpConfig: { mcpServers: Record<string, unknown> }
+  if (await exists(mcpConfigPath)) {
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(await readFile(mcpConfigPath, 'utf-8'))
+    } catch {
+      console.warn(`Skipping .mcp.json update; ${mcpConfigPath} is not valid JSON`)
+      return
+    }
+    mcpConfig =
+      parsed && typeof parsed === 'object'
+        ? (parsed as { mcpServers: Record<string, unknown> })
+        : { mcpServers: {} }
+    if (!mcpConfig.mcpServers || typeof mcpConfig.mcpServers !== 'object') {
+      mcpConfig.mcpServers = {}
+    }
+    mcpConfig.mcpServers['bricks-ctor'] = projectMcpServer
+    delete mcpConfig.mcpServers['bricks-project']
+  } else {
+    mcpConfig = { mcpServers: { 'bricks-ctor': projectMcpServer } }
+  }
+
+  await writeFile(mcpConfigPath, `${JSON.stringify(mcpConfig, null, 2)}\n`)
+  console.log(`Updated ${mcpConfigPath}`)
+}

package/tools/postinstall.ts

@@ -12,6 +12,7 @@ import {
 } from 'fs/promises'
 import * as path from 'path'
 import TOML from '@iarna/toml'
+import { handleMcpConfigOverride } from './_mcp-config'
 
 const cwd = process.cwd()
 const projectSkillsDir = path.join(cwd, '.bricks', 'skills')
@@ -80,41 +81,13 @@ type CodexMcpConfig = {
   mcp_servers: Record<string, typeof codexProjectMcpServer | typeof projectMcpServer>
 }
 
-// Claude Code and AGENTS.md projects both use the shared project .mcp.json file.
-const defaultMcpConfig = {
-  mcpServers: {
-    'bricks-ctor': 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-ctor'] = projectMcpServer
-      delete mcpConfig.mcpServers['bricks-project']
-    } catch {
-      mcpConfig = defaultMcpConfig
-    }
-  } else {
-    mcpConfig = defaultMcpConfig
-  }
-
-  await writeFile(mcpConfigPath, `${JSON.stringify(mcpConfig, null, 2)}\n`)
-
-  console.log(`Updated ${mcpConfigPath}`)
-}
-
 const hasClaudeCode = await exists(`${cwd}/CLAUDE.md`)
 const hasAgentsMd = await exists(`${cwd}/AGENTS.md`)
 
 if (hasClaudeCode || hasAgentsMd) {
   // Keep the workspace-level JSON MCP config aligned for tools that read .mcp.json.
   const mcpConfigPath = `${cwd}/.mcp.json`
-  await handleMcpConfigOverride(mcpConfigPath)
+  await handleMcpConfigOverride(mcpConfigPath, projectMcpServer)
 }
 
 const copyMissingSkills = async (sourceDir: string, targetDir: string) => {
@@ -282,18 +255,25 @@ if (hasAgentsMd) {
   }
 
   const handleCodexMcpConfigOverride = async (mcpConfigPath: string) => {
-    let mcpConfig: CodexMcpConfig | null = null
+    let mcpConfig: CodexMcpConfig
     if (await exists(mcpConfigPath)) {
-      const configStr = await readFile(mcpConfigPath, 'utf-8')
+      let parsed: unknown
       try {
-        const parsed = TOML.parse(configStr) as Partial<CodexMcpConfig>
-        if (!parsed?.mcp_servers) throw new Error('mcp_servers is not defined')
-        mcpConfig = { mcp_servers: parsed.mcp_servers }
-        mcpConfig.mcp_servers['bricks-ctor'] = codexProjectMcpServer
-        delete mcpConfig.mcp_servers['bricks-project']
+        parsed = TOML.parse(await readFile(mcpConfigPath, 'utf-8'))
       } catch {
-        mcpConfig = defaultCodexMcpConfig
+        // A malformed config is left untouched (with a warning) rather than overwritten with
+        // the default — clobbering it would silently delete the user's other server entries.
+        // Mirrors handleMcpConfigOverride's handling of a malformed .mcp.json.
+        console.warn(`Skipping .codex/config.toml update; ${mcpConfigPath} is not valid TOML`)
+        return
+      }
+      mcpConfig =
+        parsed && typeof parsed === 'object' ? (parsed as CodexMcpConfig) : { mcp_servers: {} }
+      if (!mcpConfig.mcp_servers || typeof mcpConfig.mcp_servers !== 'object') {
+        mcpConfig.mcp_servers = {}
       }
+      mcpConfig.mcp_servers['bricks-ctor'] = codexProjectMcpServer
+      delete mcpConfig.mcp_servers['bricks-project']
     } else {
       mcpConfig = defaultCodexMcpConfig
     }

package/types/bricks/Sketch.d.ts

@@ -191,9 +191,11 @@ Default property:
     /* A stroke was just committed (drawn or added programmatically) */
     onStrokeEnd?: Array<EventAction<string & keyof TemplateEventPropsMap['Sketch']['onStrokeEnd']>>
     /* The canvas was cleared */
-    onClear?: Array<EventAction>
+    onClear?: Array<EventAction<string & keyof TemplateEventPropsMap['Sketch']['onClear']>>
     /* Sketch state changed (any commit, undo, redo, clear, or import) */
-    onStateChange?: Array<EventAction>
+    onStateChange?: Array<
+      EventAction<string & keyof TemplateEventPropsMap['Sketch']['onStateChange']>
+    >
     /* Active tool changed */
     onToolChange?: Array<
       EventAction<string & keyof TemplateEventPropsMap['Sketch']['onToolChange']>

package/types/generators/Tick.d.ts

@@ -33,7 +33,7 @@ Default property:
   property?: {
     /* Start tick on generator initialized */
     init?: boolean | DataLink
-    /* Interval of second for countdown */
+    /* Tick interval in milliseconds for countdown */
     interval?: number | DataLink
     /* Initial value of countdown */
     countdownStartValue?: number | DataLink

package/utils/event-props.ts

@@ -142,7 +142,9 @@ export const templateEventPropsMap = {
     },
   },
   Sketch: {
-    onStrokeEnd: { BRICK_SKETCH_STROKE_COUNT: 'number' },
+    onStrokeEnd: { BRICK_SKETCH_STROKE_COUNT: 'number', BRICK_SKETCH_STATE: '{}' },
+    onClear: { BRICK_SKETCH_STATE: '{}' },
+    onStateChange: { BRICK_SKETCH_STATE: '{}' },
     onToolChange: { BRICK_SKETCH_TOOL: 'string' },
     onExportImage: { BRICK_SKETCH_IMAGE_URI: 'string' },
   },