@fugood/bricks-ctor 2.25.0-beta.46 → 2.25.0-beta.48

package/compile/__tests__/index.test.js

@@ -1,7 +1,14 @@
 jest.mock('../../tools/_shell', () => ({
-  sh: jest.fn(() => Promise.resolve({})),
+  sh: jest.fn(),
 }))
 
+// Mirrors the chainable `sh` result (supports `.nothrow()` like the real helper).
+const shResult = (over = {}) => {
+  const result = Promise.resolve({ exitCode: 0, stdout: '', stderr: '', ...over })
+  result.nothrow = () => result
+  return result
+}
+
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
@@ -57,7 +64,8 @@ const commandOf = ([strings, ...values]) =>
 
 describe('checkConfig', () => {
   beforeEach(() => {
-    sh.mockClear()
+    sh.mockReset()
+    sh.mockImplementation(() => shResult())
   })
 
   test('runs doctor after check-config', async () => {
@@ -68,6 +76,20 @@ describe('checkConfig', () => {
       'bricks app doctor --validate-automation .bricks/build/application-config.json',
     ])
   })
+
+  test('skips doctor when the CLI lacks the command', async () => {
+    sh.mockReturnValueOnce(shResult()) // check-config
+    sh.mockReturnValueOnce(shResult({ exitCode: 1, stderr: "error: unknown command 'doctor'" }))
+
+    await expect(checkConfig('config.json')).resolves.toBeUndefined()
+  })
+
+  test('throws when doctor reports config errors', async () => {
+    sh.mockReturnValueOnce(shResult()) // check-config
+    sh.mockReturnValueOnce(shResult({ exitCode: 1, stderr: 'DATA_RACE: conflicting writes' }))
+
+    await expect(checkConfig('config.json')).rejects.toThrow()
+  })
 })
 
 describe('compile animations', () => {

package/compile/__tests__/util.test.js

@@ -64,6 +64,28 @@ describe('validateConfig', () => {
   test('does not throw when error/output are falsy and inputs are empty', () => {
     expect(() => validateConfig(baseConfig())).not.toThrow()
   })
+
+  test('throws when error and output target the same id', () => {
+    const config = baseConfig({ output: 'shared', error: 'shared' })
+    expect(() => validateConfig(config)).toThrow(/key: error\/output/)
+  })
+
+  test('throws when output collides with an outputs target id', () => {
+    const config = baseConfig({ output: 'shared', outputs: { x: ['shared'] } })
+    expect(() => validateConfig(config)).toThrow(/key: output\/outputs/)
+  })
+
+  test('throws when error collides with an outputs target id', () => {
+    const config = baseConfig({ error: 'shared', outputs: { x: ['shared'] } })
+    expect(() => validateConfig(config)).toThrow(/key: error\/outputs/)
+  })
+
+  // The same id reused across *different* outputs entries is a supported last-wins case
+  // (see generateCalulationMap test below) and must stay allowed.
+  test('allows the same id across multiple outputs entries', () => {
+    const config = baseConfig({ outputs: { first: ['pb1'], second: ['pb1'] } })
+    expect(() => validateConfig(config)).not.toThrow()
+  })
 })
 
 // generateCalulationMap now seeds command ids from the owning calc id; tests that don't

package/compile/index.ts

@@ -1494,6 +1494,11 @@ export const checkConfig = async (configPath: string) => {
   // which catches agent-authored automations that reference deleted bricks.
   await sh`bricks app check-config --validate-automation ${configPath}`
   // Doctor adds semantic lint checks after structural validation. Warnings are
-  // surfaced in the compile log, but only errors fail by default.
-  await sh`bricks app doctor --validate-automation ${configPath}`
+  // surfaced in the compile log, but only errors fail by default. Older published
+  // bricks-cli builds lack `app doctor` — skip rather than fail the compile.
+  const doctor = await sh`bricks app doctor --validate-automation ${configPath}`.nothrow()
+  if (doctor.exitCode !== 0) {
+    if (/unknown command/i.test(doctor.stderr?.toString() ?? '')) return
+    throw new Error(`bricks app doctor failed with exit ${doctor.exitCode}`)
+  }
 }

package/compile/util.ts

@@ -27,6 +27,22 @@ export const validateConfig = (config: ScriptConfig) => {
   if (Object.values(config.outputs).some((value) => value.some((id) => config.inputs[id]))) {
     throw new Error(`${errorMsg}. key: outputs`)
   }
+  // The same data-node id reused across the output-side targets (output / error / outputs)
+  // also collides: generateCalulationMap spreads their node objects last-wins, so the later
+  // one silently overwrites the earlier wiring (e.g. error == output drops the error change
+  // link). The checks above only compare against `inputs`, so guard the output-side pairs
+  // too. (The same id appearing in multiple `outputs` entries is a supported last-wins case
+  // and stays allowed.)
+  if (config.error && config.output && config.error === config.output) {
+    throw new Error(`${errorMsg}. key: error/output`)
+  }
+  const outputsIds = Object.values(config.outputs).flat()
+  if (config.output && outputsIds.includes(config.output)) {
+    throw new Error(`${errorMsg}. key: output/outputs`)
+  }
+  if (config.error && outputsIds.includes(config.error)) {
+    throw new Error(`${errorMsg}. key: error/outputs`)
+  }
 }
 
 const padding = 15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.46",
+  "version": "2.25.0-beta.48",
   "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.46",
+    "@fugood/bricks-cli": "^2.25.0-beta.48",
     "@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": "877bdee4953bcdc09b2dd04f28c8d7edc37824ab"
+  "gitHead": "6403fb9aece6b9ee45a72a963ddc75aec5ae3e04"
 }

package/skills/bricks-ctor/references/verification-toolchain.md

@@ -122,6 +122,25 @@ Once DevTools is on, ask the user how they want to drive the verification — Ch
 
 For agent-driven CDP/MCP work against the device (`bricks devtools …` with `-a <ip> --passcode <pc>`, plus bridging the device MCP endpoint into an MCP client), the same `bricks-cli` skill referenced in Path 1 covers the on-device case — read it if installed. If not installed, run `bricks --help` and `bricks devtools --help` for the authoritative command listing.
 
+### Running real-device Automations from an agent
+
+There is no `bricks devtools automation` subcommand. Use the DevTools runtime helpers exposed inside the app:
+
+```bash
+bricks devtools runtime eval -a <ip> -p 19851 --passcode <pc> "Object.getOwnPropertyNames(automation).sort()" -j
+bricks devtools runtime eval -a <ip> -p 19851 --passcode <pc> "automation.list()" -j
+bricks devtools runtime eval -a <ip> -p 19851 --passcode <pc> "automation.run('<TEST_id>', { updateScreenshot: false })" --await -j
+```
+
+`automation.run()` starts the device-side run and may return `null`; treat that as accepted, not as a pass/fail result. Wait for the run timeout/window, then verify completion through the app's own state and a screenshot. For app state, use live runtime reads such as:
+
+```bash
+bricks devtools runtime eval -a <ip> -p 19851 --passcode <pc> "JSON.stringify({ result: system.data.property('<S_xxxx>', '<resultAlias>')?.value })" -j
+bricks devtools screenshot -a <ip> -p 19851 --passcode <pc> -o /tmp/device-automation.png
+```
+
+In CTOR Desktop sandboxed sessions, keep these as separate simple commands. Avoid multi-line shell scripts, `for` loops, brace expansion, and command substitution around `bricks devtools`; those can stay sandboxed and lose LAN/device access. After `bun update-app` or a device refresh, the DevTools socket may briefly drop, so wait and probe with one screenshot or one `runtime eval` before running the automation.
+
 ### Real-device side-effects warning
 
 Real devices fire real peripherals. Payment terminals charge. MQTT broadcasts on shared topics. BLE advertises to bystanders. Use a **staging** device for verification cycles; never iterate on a production-deployed device unless the user explicitly approves.

package/tools/mcp-tools/__tests__/huggingface.test.ts

@@ -0,0 +1,49 @@
+import { buildGGUFSplitFiles } from '../huggingface'
+
+declare const describe: (name: string, fn: () => void) => void
+declare const it: (name: string, fn: () => void) => void
+declare const expect: (actual: unknown) => { toEqual: (expected: unknown) => void }
+
+describe('buildGGUFSplitFiles', () => {
+  it('builds split GGUF files with indexed sibling metadata lookup', () => {
+    const siblings = [
+      {
+        rfilename: 'other-file.txt',
+        size: 999,
+      },
+      {
+        rfilename: 'model-00001-of-00003.gguf',
+        size: 1,
+        lfs: { sha256: 'one' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 2,
+        lfs: { sha256: 'two' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 22,
+        lfs: { sha256: 'two-late' },
+      },
+    ]
+
+    expect(buildGGUFSplitFiles('model-00001-of-00003.gguf', '00003', siblings)).toEqual([
+      {
+        rfilename: 'model-00001-of-00003.gguf',
+        size: 1,
+        lfs: { sha256: 'one' },
+      },
+      {
+        rfilename: 'model-00002-of-00003.gguf',
+        size: 2,
+        lfs: { sha256: 'two' },
+      },
+      {
+        rfilename: 'model-00003-of-00003.gguf',
+        size: undefined,
+        lfs: undefined,
+      },
+    ])
+  })
+})

package/tools/mcp-tools/__tests__/icons.test.ts

@@ -0,0 +1,21 @@
+import { searchIcons } from '../icons'
+
+declare const describe: (name: string, fn: () => void) => void
+declare const test: (name: string, fn: () => void) => void
+declare const expect: (actual: unknown) => {
+  toBe: (expected: unknown) => void
+  toHaveLength: (expected: number) => void
+}
+
+describe('icon_search helpers', () => {
+  test('searches the selected style corpus directly', () => {
+    const results = searchIcons('x', 10, 'brands')
+
+    expect(results).toHaveLength(10)
+    expect(results.every((result) => result.item.styles.includes('brands'))).toBe(true)
+  })
+
+  test('keeps unstyled searches capped by limit', () => {
+    expect(searchIcons('arrow', 5)).toHaveLength(5)
+  })
+})

package/tools/mcp-tools/huggingface.ts

@@ -269,6 +269,28 @@ const fetchHFModelDetails = async (modelId: string): Promise<HFModel> => {
 // Example: Mixtral-8x22B-v0.1.IQ3_XS-00001-of-00005.gguf
 const ggufSplitPattern = /-(\d{5})-of-(\d{5})\.gguf$/
 
+export const buildGGUFSplitFiles = (
+  filename: string,
+  splitTotal: string,
+  siblings: HFSibling[],
+): HFSibling[] => {
+  const siblingByFilename = new Map<string, HFSibling>()
+  for (const sibling of siblings) {
+    if (!siblingByFilename.has(sibling.rfilename)) siblingByFilename.set(sibling.rfilename, sibling)
+  }
+
+  return Array.from({ length: Number(splitTotal) }, (_, i) => {
+    const split = String(i + 1).padStart(5, '0')
+    const splitRFilename = filename.replace(ggufSplitPattern, `-${split}-of-${splitTotal}.gguf`)
+    const sibling = siblingByFilename.get(splitRFilename)
+    return {
+      rfilename: splitRFilename,
+      size: sibling?.size,
+      lfs: sibling?.lfs,
+    }
+  })
+}
+
 export function register(server: McpServer) {
   server.tool(
     'huggingface_search',
@@ -657,19 +679,7 @@ export function register(server: McpServer) {
 
         if (isSplit) {
           const [, , splitTotal] = matched!
-          const splitFiles = Array.from({ length: Number(splitTotal) }, (_, i) => {
-            const split = String(i + 1).padStart(5, '0')
-            const splitRFilename = filename.replace(
-              ggufSplitPattern,
-              `-${split}-of-${splitTotal}.gguf`,
-            )
-            const sibling = siblings.find((sb) => sb.rfilename === splitRFilename)
-            return {
-              rfilename: splitRFilename,
-              size: sibling?.size,
-              lfs: sibling?.lfs,
-            }
-          })
+          const splitFiles = buildGGUFSplitFiles(filename, splitTotal, siblings)
 
           const first = splitFiles[0]
           const rest = splitFiles.slice(1)

package/tools/mcp-tools/icons.ts

@@ -36,11 +36,31 @@ const iconList = Object.entries(glyphmap as Record<string, number>).map(([name,
   return { name, code, styles }
 })
 
-const iconFuse = new Fuse(iconList, {
+const fuseOptions = {
   keys: ['name'],
   threshold: 0.3,
   includeScore: true,
-})
+}
+
+const iconFuse = new Fuse(iconList, fuseOptions)
+const iconFuseByStyle = new Map<IconStyle, Fuse<(typeof iconList)[number]>>()
+
+function getStyleFuse(style: IconStyle) {
+  let fuse = iconFuseByStyle.get(style)
+  if (!fuse) {
+    fuse = new Fuse(
+      iconList.filter((icon) => icon.styles.includes(style)),
+      fuseOptions,
+    )
+    iconFuseByStyle.set(style, fuse)
+  }
+  return fuse
+}
+
+export function searchIcons(query: string, limit: number, style?: IconStyle) {
+  if (style) return getStyleFuse(style).search(query, { limit })
+  return iconFuse.search(query, { limit })
+}
 
 export function register(server: McpServer) {
   server.tool(
@@ -54,11 +74,7 @@ export function register(server: McpServer) {
         .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 results = searchIcons(query, limit, style)
 
       const icons = results.map((r) => ({
         name: r.item.name,